1 files changed, 756 insertions, 0 deletions
diff --git a/gfx/2d/ScaledFontDWrite.cpp b/gfx/2d/ScaledFontDWrite.cpp
new file mode 100644
index 0000000000..f6a0d97504
--- /dev/null
+++ b/gfx/2d/ScaledFontDWrite.cpp
@@ -0,0 +1,756 @@
+/* -*- 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 "ScaledFontDWrite.h"
+#include "gfxDWriteCommon.h"
+#include "UnscaledFontDWrite.h"
+#include "PathD2D.h"
+#include "gfxFont.h"
+#include "Logging.h"
+#include "mozilla/FontPropertyTypes.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "HelpersD2D.h"
+#include "StackArray.h"
+
+#include "dwrite_3.h"
+
+#include "PathSkia.h"
+#include "skia/include/core/SkPaint.h"
+#include "skia/include/core/SkPath.h"
+#include "skia/include/ports/SkTypeface_win.h"
+
+#include <vector>
+
+#include "cairo-win32.h"
+
+#include "HelpersWinFonts.h"
+
+namespace mozilla {
+namespace gfx {
+
+#define GASP_TAG 0x70736167
+#define GASP_DOGRAY 0x2
+
+static inline unsigned short readShort(const char* aBuf) {
+  return (*aBuf << 8) | *(aBuf + 1);
+}
+
+static bool DoGrayscale(IDWriteFontFace* aDWFace, Float ppem) {
+  void* tableContext;
+  char* tableData;
+  UINT32 tableSize;
+  BOOL exists;
+  aDWFace->TryGetFontTable(GASP_TAG, (const void**)&tableData, &tableSize,
+                           &tableContext, &exists);
+
+  if (exists) {
+    if (tableSize < 4) {
+      aDWFace->ReleaseFontTable(tableContext);
+      return true;
+    }
+    struct gaspRange {
+      unsigned short maxPPEM;   // Stored big-endian
+      unsigned short behavior;  // Stored big-endian
+    };
+    unsigned short numRanges = readShort(tableData + 2);
+    if (tableSize < (UINT)4 + numRanges * 4) {
+      aDWFace->ReleaseFontTable(tableContext);
+      return true;
+    }
+    gaspRange* ranges = (gaspRange*)(tableData + 4);
+    for (int i = 0; i < numRanges; i++) {
+      if (readShort((char*)&ranges[i].maxPPEM) >= ppem) {
+        if (!(readShort((char*)&ranges[i].behavior) & GASP_DOGRAY)) {
+          aDWFace->ReleaseFontTable(tableContext);
+          return false;
+        }
+        break;
+      }
+    }
+    aDWFace->ReleaseFontTable(tableContext);
+  }
+  return true;
+}
+
+ScaledFontDWrite::ScaledFontDWrite(IDWriteFontFace* aFontFace,
+                                   const RefPtr<UnscaledFont>& aUnscaledFont,
+                                   Float aSize, bool aUseEmbeddedBitmap,
+                                   bool aUseMultistrikeBold, bool aGDIForced,
+                                   const gfxFontStyle* aStyle)
+    : ScaledFontBase(aUnscaledFont, aSize),
+      mFontFace(aFontFace),
+      mUseEmbeddedBitmap(aUseEmbeddedBitmap),
+      mUseMultistrikeBold(aUseMultistrikeBold),
+      mGDIForced(aGDIForced) {
+  if (aStyle) {
+    mStyle = SkFontStyle(aStyle->weight.ToIntRounded(),
+                         DWriteFontStretchFromStretch(aStyle->stretch),
+                         // FIXME(jwatt): also use kOblique_Slant
+                         aStyle->style == FontSlantStyle::NORMAL
+                             ? SkFontStyle::kUpright_Slant
+                             : SkFontStyle::kItalic_Slant);
+  }
+}
+
+already_AddRefed<Path> ScaledFontDWrite::GetPathForGlyphs(
+    const GlyphBuffer& aBuffer, const DrawTarget* aTarget) {
+  RefPtr<PathBuilder> pathBuilder = aTarget->CreatePathBuilder();
+
+  if (pathBuilder->GetBackendType() != BackendType::DIRECT2D &&
+      pathBuilder->GetBackendType() != BackendType::DIRECT2D1_1) {
+    return ScaledFontBase::GetPathForGlyphs(aBuffer, aTarget);
+  }
+
+  PathBuilderD2D* pathBuilderD2D =
+      static_cast<PathBuilderD2D*>(pathBuilder.get());
+
+  CopyGlyphsToSink(aBuffer, pathBuilderD2D->GetSink());
+
+  return pathBuilder->Finish();
+}
+
+SkTypeface* ScaledFontDWrite::CreateSkTypeface() {
+  RefPtr<IDWriteFactory> factory = Factory::GetDWriteFactory();
+  if (!factory) {
+    return nullptr;
+  }
+
+  auto& settings = DWriteSettings();
+  Float gamma = settings.Gamma();
+  // Skia doesn't support a gamma value outside of 0-4, so default to 2.2
+  if (gamma < 0.0f || gamma > 4.0f) {
+    gamma = 2.2f;
+  }
+
+  Float contrast = settings.EnhancedContrast();
+  // Skia doesn't support a contrast value outside of 0-1, so default to 1.0
+  if (contrast < 0.0f || contrast > 1.0f) {
+    contrast = 1.0f;
+  }
+
+  Float clearTypeLevel = settings.ClearTypeLevel();
+  if (clearTypeLevel < 0.0f || clearTypeLevel > 1.0f) {
+    clearTypeLevel = 1.0f;
+  }
+
+  return SkCreateTypefaceFromDWriteFont(factory, mFontFace, mStyle,
+                                        (int)settings.RenderingMode(), gamma,
+                                        contrast, clearTypeLevel);
+}
+
+void ScaledFontDWrite::SetupSkFontDrawOptions(SkFont& aFont) {
+  if (ForceGDIMode()) {
+    aFont.setEmbeddedBitmaps(true);
+    aFont.setSubpixel(false);
+  } else {
+    aFont.setEmbeddedBitmaps(UseEmbeddedBitmaps());
+    aFont.setSubpixel(true);
+  }
+}
+
+bool ScaledFontDWrite::MayUseBitmaps() {
+  return ForceGDIMode() || UseEmbeddedBitmaps();
+}
+
+void ScaledFontDWrite::CopyGlyphsToBuilder(const GlyphBuffer& aBuffer,
+                                           PathBuilder* aBuilder,
+                                           const Matrix* aTransformHint) {
+  BackendType backendType = aBuilder->GetBackendType();
+  if (backendType != BackendType::DIRECT2D &&
+      backendType != BackendType::DIRECT2D1_1) {
+    ScaledFontBase::CopyGlyphsToBuilder(aBuffer, aBuilder, aTransformHint);
+    return;
+  }
+
+  PathBuilderD2D* pathBuilderD2D = static_cast<PathBuilderD2D*>(aBuilder);
+
+  if (pathBuilderD2D->IsFigureActive()) {
+    gfxCriticalNote
+        << "Attempting to copy glyphs to PathBuilderD2D with active figure.";
+  }
+
+  CopyGlyphsToSink(aBuffer, pathBuilderD2D->GetSink());
+}
+
+void ScaledFontDWrite::CopyGlyphsToSink(const GlyphBuffer& aBuffer,
+                                        ID2D1SimplifiedGeometrySink* aSink) {
+  std::vector<UINT16> indices;
+  std::vector<FLOAT> advances;
+  std::vector<DWRITE_GLYPH_OFFSET> offsets;
+  indices.resize(aBuffer.mNumGlyphs);
+  advances.resize(aBuffer.mNumGlyphs);
+  offsets.resize(aBuffer.mNumGlyphs);
+
+  memset(&advances.front(), 0, sizeof(FLOAT) * aBuffer.mNumGlyphs);
+  for (unsigned int i = 0; i < aBuffer.mNumGlyphs; i++) {
+    indices[i] = aBuffer.mGlyphs[i].mIndex;
+    offsets[i].advanceOffset = aBuffer.mGlyphs[i].mPosition.x;
+    offsets[i].ascenderOffset = -aBuffer.mGlyphs[i].mPosition.y;
+  }
+
+  HRESULT hr = mFontFace->GetGlyphRunOutline(
+      mSize, &indices.front(), &advances.front(), &offsets.front(),
+      aBuffer.mNumGlyphs, FALSE, FALSE, aSink);
+  if (FAILED(hr)) {
+    gfxCriticalNote << "Failed to copy glyphs to geometry sink. Code: "
+                    << hexa(hr);
+  }
+}
+
+bool UnscaledFontDWrite::GetFontFileData(FontFileDataOutput aDataCallback,
+                                         void* aBaton) {
+  UINT32 fileCount = 0;
+  HRESULT hr = mFontFace->GetFiles(&fileCount, nullptr);
+
+  if (FAILED(hr) || fileCount > 1) {
+    MOZ_ASSERT(false);
+    return false;
+  }
+
+  if (!aDataCallback) {
+    return true;
+  }
+
+  RefPtr<IDWriteFontFile> file;
+  hr = mFontFace->GetFiles(&fileCount, getter_AddRefs(file));
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  const void* referenceKey;
+  UINT32 refKeySize;
+  // XXX - This can currently crash for webfonts, as when we get the reference
+  // key out of the file, that can be an invalid reference key for the loader
+  // we use it with. The fix to this is not obvious but it will probably
+  // have to happen inside thebes.
+  hr = file->GetReferenceKey(&referenceKey, &refKeySize);
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  RefPtr<IDWriteFontFileLoader> loader;
+  hr = file->GetLoader(getter_AddRefs(loader));
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  RefPtr<IDWriteFontFileStream> stream;
+  hr = loader->CreateStreamFromKey(referenceKey, refKeySize,
+                                   getter_AddRefs(stream));
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  UINT64 fileSize64;
+  hr = stream->GetFileSize(&fileSize64);
+  if (FAILED(hr) || fileSize64 > UINT32_MAX) {
+    MOZ_ASSERT(false);
+    return false;
+  }
+
+  // Try to catch any device memory exceptions that may occur while attempting
+  // to read the file fragment.
+  void* context = nullptr;
+  hr = E_FAIL;
+  MOZ_SEH_TRY {
+    uint32_t fileSize = static_cast<uint32_t>(fileSize64);
+    const void* fragmentStart = nullptr;
+    hr = stream->ReadFileFragment(&fragmentStart, 0, fileSize, &context);
+    if (SUCCEEDED(hr)) {
+      aDataCallback((uint8_t*)fragmentStart, fileSize, mFontFace->GetIndex(),
+                    aBaton);
+    }
+  }
+  MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+    gfxCriticalNote << "Exception occurred reading DWrite font file data";
+  }
+  if (FAILED(hr)) {
+    return false;
+  }
+  stream->ReleaseFileFragment(context);
+  return true;
+}
+
+static bool GetFontFileName(RefPtr<IDWriteFontFace> aFontFace,
+                            std::vector<WCHAR>& aFileName) {
+  UINT32 numFiles;
+  HRESULT hr = aFontFace->GetFiles(&numFiles, nullptr);
+  if (FAILED(hr)) {
+    gfxDebug() << "Failed getting file count for WR font";
+    return false;
+  } else if (numFiles != 1) {
+    gfxDebug() << "Invalid file count " << numFiles << " for WR font";
+    return false;
+  }
+
+  RefPtr<IDWriteFontFile> file;
+  hr = aFontFace->GetFiles(&numFiles, getter_AddRefs(file));
+  if (FAILED(hr)) {
+    gfxDebug() << "Failed getting file for WR font";
+    return false;
+  }
+
+  const void* key;
+  UINT32 keySize;
+  hr = file->GetReferenceKey(&key, &keySize);
+  if (FAILED(hr)) {
+    gfxDebug() << "Failed getting file ref key for WR font";
+    return false;
+  }
+  RefPtr<IDWriteFontFileLoader> loader;
+  hr = file->GetLoader(getter_AddRefs(loader));
+  if (FAILED(hr)) {
+    gfxDebug() << "Failed getting file loader for WR font";
+    return false;
+  }
+  RefPtr<IDWriteLocalFontFileLoader> localLoader;
+  loader->QueryInterface(__uuidof(IDWriteLocalFontFileLoader),
+                         (void**)getter_AddRefs(localLoader));
+  if (!localLoader) {
+    gfxDebug() << "Failed querying loader interface for WR font";
+    return false;
+  }
+  UINT32 pathLen;
+  hr = localLoader->GetFilePathLengthFromKey(key, keySize, &pathLen);
+  if (FAILED(hr)) {
+    gfxDebug() << "Failed getting path length for WR font";
+    return false;
+  }
+  aFileName.resize(pathLen + 1);
+  hr = localLoader->GetFilePathFromKey(key, keySize, aFileName.data(),
+                                       pathLen + 1);
+  if (FAILED(hr) || aFileName.back() != 0) {
+    gfxDebug() << "Failed getting path for WR font";
+    return false;
+  }
+  DWORD attribs = GetFileAttributesW(aFileName.data());
+  if (attribs == INVALID_FILE_ATTRIBUTES) {
+    gfxDebug() << "Invalid file \"" << aFileName.data() << "\" for WR font";
+    return false;
+  }
+  // We leave the null terminator at the end of the returned file name.
+  return true;
+}
+
+bool UnscaledFontDWrite::GetFontDescriptor(FontDescriptorOutput aCb,
+                                           void* aBaton) {
+  if (!mFont) {
+    return false;
+  }
+
+  std::vector<WCHAR> fileName;
+  if (!GetFontFileName(mFontFace, fileName)) {
+    return false;
+  }
+  uint32_t index = mFontFace->GetIndex();
+
+  aCb(reinterpret_cast<const uint8_t*>(fileName.data()),
+      fileName.size() * sizeof(WCHAR), index, aBaton);
+  return true;
+}
+
+ScaledFontDWrite::InstanceData::InstanceData(
+    const wr::FontInstanceOptions* aOptions,
+    const wr::FontInstancePlatformOptions* aPlatformOptions) {
+  if (aOptions) {
+    if (aOptions->flags & wr::FontInstanceFlags::EMBEDDED_BITMAPS) {
+      mUseEmbeddedBitmap = true;
+    }
+    if (aOptions->flags & wr::FontInstanceFlags::SYNTHETIC_BOLD) {
+      mUseBoldSimulation = true;
+    }
+    if (aOptions->flags & wr::FontInstanceFlags::MULTISTRIKE_BOLD) {
+      mUseMultistrikeBold = true;
+    }
+    if (aOptions->flags & wr::FontInstanceFlags::FORCE_GDI) {
+      mGDIForced = true;
+    }
+  }
+}
+
+bool ScaledFontDWrite::HasVariationSettings() {
+  RefPtr<IDWriteFontFace5> ff5;
+  mFontFace->QueryInterface(__uuidof(IDWriteFontFace5),
+                            (void**)getter_AddRefs(ff5));
+  if (!ff5 || !ff5->HasVariations()) {
+    return false;
+  }
+
+  uint32_t count = ff5->GetFontAxisValueCount();
+  if (!count) {
+    return false;
+  }
+
+  RefPtr<IDWriteFontResource> res;
+  if (FAILED(ff5->GetFontResource(getter_AddRefs(res)))) {
+    return false;
+  }
+
+  std::vector<DWRITE_FONT_AXIS_VALUE> defaults(count);
+  if (FAILED(res->GetDefaultFontAxisValues(defaults.data(), count))) {
+    return false;
+  }
+
+  std::vector<DWRITE_FONT_AXIS_VALUE> values(count);
+  if (FAILED(ff5->GetFontAxisValues(values.data(), count))) {
+    return false;
+  }
+
+  for (uint32_t i = 0; i < count; i++) {
+    DWRITE_FONT_AXIS_ATTRIBUTES attr = res->GetFontAxisAttributes(i);
+    if (attr & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE) {
+      if (values[i].value != defaults[i].value) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// Helper for ScaledFontDWrite::GetFontInstanceData: if the font has variation
+// axes, get their current values into the aOutput vector.
+static void GetVariationsFromFontFace(IDWriteFontFace* aFace,
+                                      std::vector<FontVariation>* aOutput) {
+  RefPtr<IDWriteFontFace5> ff5;
+  aFace->QueryInterface(__uuidof(IDWriteFontFace5),
+                        (void**)getter_AddRefs(ff5));
+  if (!ff5 || !ff5->HasVariations()) {
+    return;
+  }
+
+  uint32_t count = ff5->GetFontAxisValueCount();
+  if (!count) {
+    return;
+  }
+
+  RefPtr<IDWriteFontResource> res;
+  if (FAILED(ff5->GetFontResource(getter_AddRefs(res)))) {
+    return;
+  }
+
+  std::vector<DWRITE_FONT_AXIS_VALUE> values(count);
+  if (FAILED(ff5->GetFontAxisValues(values.data(), count))) {
+    return;
+  }
+
+  aOutput->reserve(count);
+  for (uint32_t i = 0; i < count; i++) {
+    DWRITE_FONT_AXIS_ATTRIBUTES attr = res->GetFontAxisAttributes(i);
+    if (attr & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE) {
+      float v = values[i].value;
+      uint32_t t = TRUETYPE_TAG(
+          uint8_t(values[i].axisTag), uint8_t(values[i].axisTag >> 8),
+          uint8_t(values[i].axisTag >> 16), uint8_t(values[i].axisTag >> 24));
+      aOutput->push_back(FontVariation{uint32_t(t), float(v)});
+    }
+  }
+}
+
+bool ScaledFontDWrite::GetFontInstanceData(FontInstanceDataOutput aCb,
+                                           void* aBaton) {
+  InstanceData instance(this);
+
+  // If the font has variations, get the list of axis values.
+  std::vector<FontVariation> variations;
+  GetVariationsFromFontFace(mFontFace, &variations);
+
+  aCb(reinterpret_cast<uint8_t*>(&instance), sizeof(instance),
+      variations.data(), variations.size(), aBaton);
+
+  return true;
+}
+
+bool ScaledFontDWrite::GetWRFontInstanceOptions(
+    Maybe<wr::FontInstanceOptions>* aOutOptions,
+    Maybe<wr::FontInstancePlatformOptions>* aOutPlatformOptions,
+    std::vector<FontVariation>* aOutVariations) {
+  wr::FontInstanceOptions options;
+  options.render_mode = wr::ToFontRenderMode(GetDefaultAAMode());
+  options.flags = wr::FontInstanceFlags{0};
+  if (HasBoldSimulation()) {
+    options.flags |= wr::FontInstanceFlags::SYNTHETIC_BOLD;
+  }
+  if (UseMultistrikeBold()) {
+    options.flags |= wr::FontInstanceFlags::MULTISTRIKE_BOLD;
+  }
+  if (UseEmbeddedBitmaps()) {
+    options.flags |= wr::FontInstanceFlags::EMBEDDED_BITMAPS;
+  }
+  if (ForceGDIMode()) {
+    options.flags |= wr::FontInstanceFlags::FORCE_GDI;
+  } else {
+    options.flags |= wr::FontInstanceFlags::SUBPIXEL_POSITION;
+  }
+  auto& settings = DWriteSettings();
+  switch (settings.RenderingMode()) {
+    case DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC:
+      options.flags |= wr::FontInstanceFlags::FORCE_SYMMETRIC;
+      break;
+    case DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL:
+      options.flags |= wr::FontInstanceFlags::NO_SYMMETRIC;
+      break;
+    default:
+      break;
+  }
+  if (Factory::GetBGRSubpixelOrder()) {
+    options.flags |= wr::FontInstanceFlags::SUBPIXEL_BGR;
+  }
+  options.synthetic_italics =
+      wr::DegreesToSyntheticItalics(GetSyntheticObliqueAngle());
+
+  wr::FontInstancePlatformOptions platformOptions;
+  platformOptions.gamma = uint16_t(std::round(settings.Gamma() * 100.0f));
+  platformOptions.contrast =
+      uint8_t(std::round(std::min(settings.EnhancedContrast(), 1.0f) * 100.0f));
+  platformOptions.cleartype_level =
+      uint8_t(std::round(std::min(settings.ClearTypeLevel(), 1.0f) * 100.0f));
+
+  *aOutOptions = Some(options);
+  *aOutPlatformOptions = Some(platformOptions);
+
+  GetVariationsFromFontFace(mFontFace, aOutVariations);
+
+  return true;
+}
+
+DWriteSettings& ScaledFontDWrite::DWriteSettings() const {
+  return DWriteSettings::Get(mGDIForced);
+}
+
+// Helper for UnscaledFontDWrite::CreateScaledFont: create a clone of the
+// given IDWriteFontFace, with specified variation-axis values applied.
+// Returns nullptr in case of failure.
+static already_AddRefed<IDWriteFontFace5> CreateFaceWithVariations(
+    IDWriteFontFace* aFace, DWRITE_FONT_SIMULATIONS aSimulations,
+    const FontVariation* aVariations = nullptr, uint32_t aNumVariations = 0) {
+  auto makeDWriteAxisTag = [](uint32_t aTag) {
+    return DWRITE_MAKE_FONT_AXIS_TAG((aTag >> 24) & 0xff, (aTag >> 16) & 0xff,
+                                     (aTag >> 8) & 0xff, aTag & 0xff);
+  };
+
+  MOZ_SEH_TRY {
+    RefPtr<IDWriteFontFace5> ff5;
+    aFace->QueryInterface(__uuidof(IDWriteFontFace5),
+                          (void**)getter_AddRefs(ff5));
+    if (!ff5) {
+      return nullptr;
+    }
+
+    RefPtr<IDWriteFontResource> res;
+    if (FAILED(ff5->GetFontResource(getter_AddRefs(res)))) {
+      return nullptr;
+    }
+
+    std::vector<DWRITE_FONT_AXIS_VALUE> fontAxisValues;
+    if (aNumVariations) {
+      fontAxisValues.reserve(aNumVariations);
+      for (uint32_t i = 0; i < aNumVariations; i++) {
+        DWRITE_FONT_AXIS_VALUE axisValue = {
+            makeDWriteAxisTag(aVariations[i].mTag), aVariations[i].mValue};
+        fontAxisValues.push_back(axisValue);
+      }
+    } else {
+      uint32_t count = ff5->GetFontAxisValueCount();
+      if (count) {
+        fontAxisValues.resize(count);
+        if (FAILED(ff5->GetFontAxisValues(fontAxisValues.data(), count))) {
+          fontAxisValues.clear();
+        }
+      }
+    }
+
+    RefPtr<IDWriteFontFace5> newFace;
+    if (FAILED(res->CreateFontFace(aSimulations, fontAxisValues.data(),
+                                   fontAxisValues.size(),
+                                   getter_AddRefs(newFace)))) {
+      return nullptr;
+    }
+    return newFace.forget();
+  }
+  MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+    gfxCriticalNote << "Exception occurred initializing variation face";
+    return nullptr;
+  }
+}
+
+bool UnscaledFontDWrite::InitBold() {
+  if (mFontFaceBold) {
+    return true;
+  }
+
+  DWRITE_FONT_SIMULATIONS sims = mFontFace->GetSimulations();
+  if (sims & DWRITE_FONT_SIMULATIONS_BOLD) {
+    mFontFaceBold = mFontFace;
+    return true;
+  }
+  sims |= DWRITE_FONT_SIMULATIONS_BOLD;
+
+  RefPtr<IDWriteFontFace5> ff5 = CreateFaceWithVariations(mFontFace, sims);
+  if (ff5) {
+    mFontFaceBold = ff5;
+  } else {
+    MOZ_SEH_TRY {
+      UINT32 numFiles = 0;
+      if (FAILED(mFontFace->GetFiles(&numFiles, nullptr))) {
+        return false;
+      }
+      StackArray<IDWriteFontFile*, 1> files(numFiles);
+      if (FAILED(mFontFace->GetFiles(&numFiles, files.data()))) {
+        return false;
+      }
+      HRESULT hr = Factory::GetDWriteFactory()->CreateFontFace(
+          mFontFace->GetType(), numFiles, files.data(), mFontFace->GetIndex(),
+          sims, getter_AddRefs(mFontFaceBold));
+      for (UINT32 i = 0; i < numFiles; ++i) {
+        files[i]->Release();
+      }
+      if (FAILED(hr) || !mFontFaceBold) {
+        return false;
+      }
+    }
+    MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+      gfxCriticalNote << "Exception occurred initializing bold face";
+      return false;
+    }
+  }
+  return true;
+}
+
+already_AddRefed<ScaledFont> UnscaledFontDWrite::CreateScaledFont(
+    Float aGlyphSize, const uint8_t* aInstanceData,
+    uint32_t aInstanceDataLength, const FontVariation* aVariations,
+    uint32_t aNumVariations) {
+  if (aInstanceDataLength < sizeof(ScaledFontDWrite::InstanceData)) {
+    gfxWarning() << "DWrite scaled font instance data is truncated.";
+    return nullptr;
+  }
+  const ScaledFontDWrite::InstanceData& instanceData =
+      *reinterpret_cast<const ScaledFontDWrite::InstanceData*>(aInstanceData);
+
+  IDWriteFontFace* face = mFontFace;
+  if (instanceData.mUseBoldSimulation) {
+    if (!InitBold()) {
+      gfxWarning() << "Failed creating bold IDWriteFontFace.";
+      return nullptr;
+    }
+    face = mFontFaceBold;
+  }
+  DWRITE_FONT_SIMULATIONS sims = face->GetSimulations();
+
+  // If variations are required, we create a separate IDWriteFontFace5 with
+  // the requested settings applied.
+  RefPtr<IDWriteFontFace5> ff5;
+  if (aNumVariations) {
+    ff5 =
+        CreateFaceWithVariations(mFontFace, sims, aVariations, aNumVariations);
+    if (ff5) {
+      face = ff5;
+    } else {
+      gfxWarning() << "Failed to create IDWriteFontFace5 with variations.";
+    }
+  }
+
+  return MakeAndAddRef<ScaledFontDWrite>(
+      face, this, aGlyphSize, instanceData.mUseEmbeddedBitmap,
+      instanceData.mUseMultistrikeBold, instanceData.mGDIForced, nullptr);
+}
+
+already_AddRefed<ScaledFont> UnscaledFontDWrite::CreateScaledFontFromWRFont(
+    Float aGlyphSize, const wr::FontInstanceOptions* aOptions,
+    const wr::FontInstancePlatformOptions* aPlatformOptions,
+    const FontVariation* aVariations, uint32_t aNumVariations) {
+  ScaledFontDWrite::InstanceData instanceData(aOptions, aPlatformOptions);
+  return CreateScaledFont(aGlyphSize, reinterpret_cast<uint8_t*>(&instanceData),
+                          sizeof(instanceData), aVariations, aNumVariations);
+}
+
+AntialiasMode ScaledFontDWrite::GetDefaultAAMode() {
+  AntialiasMode defaultMode = GetSystemDefaultAAMode();
+
+  switch (defaultMode) {
+    case AntialiasMode::SUBPIXEL:
+    case AntialiasMode::DEFAULT:
+      if (DWriteSettings().ClearTypeLevel() == 0.0f) {
+        defaultMode = AntialiasMode::GRAY;
+      }
+      break;
+    case AntialiasMode::GRAY:
+      if (!DoGrayscale(mFontFace, mSize)) {
+        defaultMode = AntialiasMode::NONE;
+      }
+      break;
+    case AntialiasMode::NONE:
+      break;
+  }
+
+  return defaultMode;
+}
+
+cairo_font_face_t* ScaledFontDWrite::CreateCairoFontFace(
+    cairo_font_options_t* aFontOptions) {
+  if (!mFontFace) {
+    return nullptr;
+  }
+
+  return cairo_dwrite_font_face_create_for_dwrite_fontface(nullptr, mFontFace);
+}
+
+void ScaledFontDWrite::PrepareCairoScaledFont(cairo_scaled_font_t* aFont) {
+  if (mGDIForced) {
+    cairo_dwrite_scaled_font_set_force_GDI_classic(aFont, true);
+  }
+}
+
+already_AddRefed<UnscaledFont> UnscaledFontDWrite::CreateFromFontDescriptor(
+    const uint8_t* aData, uint32_t aDataLength, uint32_t aIndex) {
+  // Note that despite the type of aData here, it actually points to a 16-bit
+  // Windows font file path (hence the cast to WCHAR* below).
+  if (aDataLength == 0) {
+    gfxWarning() << "DWrite font descriptor is truncated.";
+    return nullptr;
+  }
+
+  RefPtr<IDWriteFactory> factory = Factory::GetDWriteFactory();
+  if (!factory) {
+    return nullptr;
+  }
+
+  MOZ_SEH_TRY {
+    RefPtr<IDWriteFontFile> fontFile;
+    HRESULT hr = factory->CreateFontFileReference((const WCHAR*)aData, nullptr,
+                                                  getter_AddRefs(fontFile));
+    if (FAILED(hr)) {
+      return nullptr;
+    }
+    BOOL isSupported;
+    DWRITE_FONT_FILE_TYPE fileType;
+    DWRITE_FONT_FACE_TYPE faceType;
+    UINT32 numFaces;
+    hr = fontFile->Analyze(&isSupported, &fileType, &faceType, &numFaces);
+    if (FAILED(hr) || !isSupported || aIndex >= numFaces) {
+      return nullptr;
+    }
+    IDWriteFontFile* fontFiles[1] = {fontFile.get()};
+    RefPtr<IDWriteFontFace> fontFace;
+    hr = factory->CreateFontFace(faceType, 1, fontFiles, aIndex,
+                                 DWRITE_FONT_SIMULATIONS_NONE,
+                                 getter_AddRefs(fontFace));
+    if (FAILED(hr)) {
+      return nullptr;
+    }
+    RefPtr unscaledFont = new UnscaledFontDWrite(fontFace, nullptr);
+    return unscaledFont.forget();
+  }
+  MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+    gfxCriticalNote << "Exception occurred creating unscaledFont for "
+                    << NS_ConvertUTF16toUTF8((const char16_t*)aData).get();
+    return nullptr;
+  }
+}
+
+}  // namespace gfx
+}  // namespace mozilla