Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 956 insertions, 0 deletions

diff --git a/layout/style/FontFaceSetImpl.cpp b/layout/style/FontFaceSetImpl.cpp
new file mode 100644
index 0000000000..9d572701aa
--- /dev/null
+++ b/layout/style/FontFaceSetImpl.cpp
@@ -0,0 +1,956 @@
+/* -*- 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 "FontFaceSetImpl.h"
+
+#include "gfxFontConstants.h"
+#include "gfxFontSrcPrincipal.h"
+#include "gfxFontSrcURI.h"
+#include "gfxFontUtils.h"
+#include "gfxPlatformFontList.h"
+#include "mozilla/css/Loader.h"
+#include "mozilla/dom/CSSFontFaceRule.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/FontFaceImpl.h"
+#include "mozilla/dom/FontFaceSet.h"
+#include "mozilla/dom/FontFaceSetBinding.h"
+#include "mozilla/dom/FontFaceSetLoadEvent.h"
+#include "mozilla/dom/FontFaceSetLoadEventBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/WorkerCommon.h"
+#include "mozilla/dom/WorkerRunnable.h"
+#include "mozilla/FontPropertyTypes.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/PresShellInlines.h"
+#include "mozilla/ServoBindings.h"
+#include "mozilla/ServoCSSParser.h"
+#include "mozilla/ServoStyleSet.h"
+#include "mozilla/ServoUtils.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/LoadInfo.h"
+#include "nsComponentManagerUtils.h"
+#include "nsContentUtils.h"
+#include "nsDeviceContext.h"
+#include "nsFontFaceLoader.h"
+#include "nsIConsoleService.h"
+#include "nsIContentPolicy.h"
+#include "nsIDocShell.h"
+#include "nsILoadContext.h"
+#include "nsIPrincipal.h"
+#include "nsIWebNavigation.h"
+#include "nsNetUtil.h"
+#include "nsIInputStream.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+#include "nsPrintfCString.h"
+#include "nsUTF8Utils.h"
+#include "nsDOMNavigationTiming.h"
+#include "ReferrerInfo.h"
+
+using namespace mozilla;
+using namespace mozilla::css;
+using namespace mozilla::dom;
+
+#define LOG(args) \
+  MOZ_LOG(gfxUserFontSet::GetUserFontsLog(), mozilla::LogLevel::Debug, args)
+#define LOG_ENABLED() \
+  MOZ_LOG_TEST(gfxUserFontSet::GetUserFontsLog(), LogLevel::Debug)
+
+NS_IMPL_ISUPPORTS0(FontFaceSetImpl)
+
+FontFaceSetImpl::FontFaceSetImpl(FontFaceSet* aOwner)
+    : mMutex("mozilla::dom::FontFaceSetImpl"),
+      mOwner(aOwner),
+      mStatus(FontFaceSetLoadStatus::Loaded),
+      mNonRuleFacesDirty(false),
+      mHasLoadingFontFaces(false),
+      mHasLoadingFontFacesIsDirty(false),
+      mDelayedLoadCheck(false),
+      mBypassCache(false),
+      mPrivateBrowsing(false) {}
+
+FontFaceSetImpl::~FontFaceSetImpl() {
+  // Assert that we don't drop any FontFaceSet objects during a Servo traversal,
+  // since PostTraversalTask objects can hold raw pointers to FontFaceSets.
+  MOZ_ASSERT(!gfxFontUtils::IsInServoTraversal());
+
+  Destroy();
+}
+
+void FontFaceSetImpl::DestroyLoaders() {
+  mMutex.AssertCurrentThreadIn();
+  if (mLoaders.IsEmpty()) {
+    return;
+  }
+  if (NS_IsMainThread()) {
+    for (const auto& key : mLoaders.Keys()) {
+      key->Cancel();
+    }
+    mLoaders.Clear();
+    return;
+  }
+
+  class DestroyLoadersRunnable final : public Runnable {
+   public:
+    explicit DestroyLoadersRunnable(FontFaceSetImpl* aFontFaceSet)
+        : Runnable("FontFaceSetImpl::DestroyLoaders"),
+          mFontFaceSet(aFontFaceSet) {}
+
+   protected:
+    ~DestroyLoadersRunnable() override = default;
+
+    NS_IMETHOD Run() override {
+      RecursiveMutexAutoLock lock(mFontFaceSet->mMutex);
+      mFontFaceSet->DestroyLoaders();
+      return NS_OK;
+    }
+
+    // We need to save a reference to the FontFaceSetImpl because the
+    // loaders contain a non-owning reference to it.
+    RefPtr<FontFaceSetImpl> mFontFaceSet;
+  };
+
+  auto runnable = MakeRefPtr<DestroyLoadersRunnable>(this);
+  NS_DispatchToMainThread(runnable);
+}
+
+void FontFaceSetImpl::Destroy() {
+  nsTArray<FontFaceRecord> nonRuleFaces;
+  nsRefPtrHashtable<nsCStringHashKey, gfxUserFontFamily> fontFamilies;
+
+  {
+    RecursiveMutexAutoLock lock(mMutex);
+    DestroyLoaders();
+    nonRuleFaces = std::move(mNonRuleFaces);
+    fontFamilies = std::move(mFontFamilies);
+    mOwner = nullptr;
+  }
+
+  if (gfxPlatformFontList* fp = gfxPlatformFontList::PlatformFontList()) {
+    fp->RemoveUserFontSet(this);
+  }
+}
+
+void FontFaceSetImpl::ParseFontShorthandForMatching(
+    const nsACString& aFont, StyleFontFamilyList& aFamilyList,
+    FontWeight& aWeight, FontStretch& aStretch, FontSlantStyle& aStyle,
+    ErrorResult& aRv) {
+  RefPtr<URLExtraData> url = GetURLExtraData();
+  if (!url) {
+    aRv.ThrowInvalidStateError("Missing URLExtraData");
+    return;
+  }
+
+  if (!ServoCSSParser::ParseFontShorthandForMatching(
+          aFont, url, aFamilyList, aStyle, aStretch, aWeight)) {
+    aRv.ThrowSyntaxError("Invalid font shorthand");
+    return;
+  }
+}
+
+static bool HasAnyCharacterInUnicodeRange(gfxUserFontEntry* aEntry,
+                                          const nsAString& aInput) {
+  const char16_t* p = aInput.Data();
+  const char16_t* end = p + aInput.Length();
+
+  while (p < end) {
+    uint32_t c = UTF16CharEnumerator::NextChar(&p, end);
+    if (aEntry->CharacterInUnicodeRange(c)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void FontFaceSetImpl::FindMatchingFontFaces(const nsACString& aFont,
+                                            const nsAString& aText,
+                                            nsTArray<FontFace*>& aFontFaces,
+                                            ErrorResult& aRv) {
+  RecursiveMutexAutoLock lock(mMutex);
+
+  StyleFontFamilyList familyList;
+  FontWeight weight;
+  FontStretch stretch;
+  FontSlantStyle italicStyle;
+  ParseFontShorthandForMatching(aFont, familyList, weight, stretch, italicStyle,
+                                aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  gfxFontStyle style;
+  style.style = italicStyle;
+  style.weight = weight;
+  style.stretch = stretch;
+
+  // Set of FontFaces that we want to return.
+  nsTHashSet<FontFace*> matchingFaces;
+
+  for (const StyleSingleFontFamily& fontFamilyName : familyList.list.AsSpan()) {
+    if (!fontFamilyName.IsFamilyName()) {
+      continue;
+    }
+
+    const auto& name = fontFamilyName.AsFamilyName();
+    RefPtr<gfxFontFamily> family =
+        LookupFamily(nsAtomCString(name.name.AsAtom()));
+
+    if (!family) {
+      continue;
+    }
+
+    AutoTArray<gfxFontEntry*, 4> entries;
+    family->FindAllFontsForStyle(style, entries);
+
+    for (gfxFontEntry* e : entries) {
+      FontFaceImpl::Entry* entry = static_cast<FontFaceImpl::Entry*>(e);
+      if (HasAnyCharacterInUnicodeRange(entry, aText)) {
+        entry->FindFontFaceOwners(matchingFaces);
+      }
+    }
+  }
+
+  if (matchingFaces.IsEmpty()) {
+    return;
+  }
+
+  // Add all FontFaces in matchingFaces to aFontFaces, in the order
+  // they appear in the FontFaceSet.
+  FindMatchingFontFaces(matchingFaces, aFontFaces);
+}
+
+void FontFaceSetImpl::FindMatchingFontFaces(
+    const nsTHashSet<FontFace*>& aMatchingFaces,
+    nsTArray<FontFace*>& aFontFaces) {
+  RecursiveMutexAutoLock lock(mMutex);
+  for (FontFaceRecord& record : mNonRuleFaces) {
+    FontFace* owner = record.mFontFace->GetOwner();
+    if (owner && aMatchingFaces.Contains(owner)) {
+      aFontFaces.AppendElement(owner);
+    }
+  }
+}
+
+bool FontFaceSetImpl::ReadyPromiseIsPending() const {
+  RecursiveMutexAutoLock lock(mMutex);
+  return mOwner && mOwner->ReadyPromiseIsPending();
+}
+
+FontFaceSetLoadStatus FontFaceSetImpl::Status() {
+  RecursiveMutexAutoLock lock(mMutex);
+  FlushUserFontSet();
+  return mStatus;
+}
+
+bool FontFaceSetImpl::Add(FontFaceImpl* aFontFace, ErrorResult& aRv) {
+  RecursiveMutexAutoLock lock(mMutex);
+  FlushUserFontSet();
+
+  if (aFontFace->IsInFontFaceSet(this)) {
+    return false;
+  }
+
+  if (aFontFace->HasRule()) {
+    aRv.ThrowInvalidModificationError(
+        "Can't add face to FontFaceSet that comes from an @font-face rule");
+    return false;
+  }
+
+  aFontFace->AddFontFaceSet(this);
+
+#ifdef DEBUG
+  for (const FontFaceRecord& rec : mNonRuleFaces) {
+    MOZ_ASSERT(rec.mFontFace != aFontFace,
+               "FontFace should not occur in mNonRuleFaces twice");
+  }
+#endif
+
+  FontFaceRecord* rec = mNonRuleFaces.AppendElement();
+  rec->mFontFace = aFontFace;
+  rec->mOrigin = Nothing();
+
+  mNonRuleFacesDirty = true;
+  MarkUserFontSetDirty();
+  mHasLoadingFontFacesIsDirty = true;
+  CheckLoadingStarted();
+  return true;
+}
+
+void FontFaceSetImpl::Clear() {
+  RecursiveMutexAutoLock lock(mMutex);
+  FlushUserFontSet();
+
+  if (mNonRuleFaces.IsEmpty()) {
+    return;
+  }
+
+  for (size_t i = 0; i < mNonRuleFaces.Length(); i++) {
+    FontFaceImpl* f = mNonRuleFaces[i].mFontFace;
+    f->RemoveFontFaceSet(this);
+  }
+
+  mNonRuleFaces.Clear();
+  mNonRuleFacesDirty = true;
+  MarkUserFontSetDirty();
+  mHasLoadingFontFacesIsDirty = true;
+  CheckLoadingFinished();
+}
+
+bool FontFaceSetImpl::Delete(FontFaceImpl* aFontFace) {
+  RecursiveMutexAutoLock lock(mMutex);
+  FlushUserFontSet();
+
+  if (aFontFace->HasRule()) {
+    return false;
+  }
+
+  bool removed = false;
+  for (size_t i = 0; i < mNonRuleFaces.Length(); i++) {
+    if (mNonRuleFaces[i].mFontFace == aFontFace) {
+      mNonRuleFaces.RemoveElementAt(i);
+      removed = true;
+      break;
+    }
+  }
+  if (!removed) {
+    return false;
+  }
+
+  aFontFace->RemoveFontFaceSet(this);
+
+  mNonRuleFacesDirty = true;
+  MarkUserFontSetDirty();
+  mHasLoadingFontFacesIsDirty = true;
+  CheckLoadingFinished();
+  return true;
+}
+
+bool FontFaceSetImpl::HasAvailableFontFace(FontFaceImpl* aFontFace) {
+  return aFontFace->IsInFontFaceSet(this);
+}
+
+void FontFaceSetImpl::RemoveLoader(nsFontFaceLoader* aLoader) {
+  RecursiveMutexAutoLock lock(mMutex);
+  mLoaders.RemoveEntry(aLoader);
+}
+
+void FontFaceSetImpl::InsertNonRuleFontFace(FontFaceImpl* aFontFace,
+                                            bool& aFontSetModified) {
+  gfxUserFontAttributes attr;
+  if (!aFontFace->GetAttributes(attr)) {
+    // If there is no family name, this rule cannot contribute a
+    // usable font, so there is no point in processing it further.
+    return;
+  }
+
+  nsAutoCString family(attr.mFamilyName);
+
+  // Just create a new font entry if we haven't got one already.
+  if (!aFontFace->GetUserFontEntry()) {
+    // XXX Should we be checking mLocalRulesUsed like InsertRuleFontFace does?
+    RefPtr<gfxUserFontEntry> entry = FindOrCreateUserFontEntryFromFontFace(
+        aFontFace, std::move(attr), StyleOrigin::Author);
+    if (!entry) {
+      return;
+    }
+    aFontFace->SetUserFontEntry(entry);
+  }
+
+  aFontSetModified = true;
+  AddUserFontEntry(family, aFontFace->GetUserFontEntry());
+}
+
+void FontFaceSetImpl::UpdateUserFontEntry(gfxUserFontEntry* aEntry,
+                                          gfxUserFontAttributes&& aAttr) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  bool resetFamilyName = !aEntry->mFamilyName.IsEmpty() &&
+                         aEntry->mFamilyName != aAttr.mFamilyName;
+  // aFontFace already has a user font entry, so we update its attributes
+  // rather than creating a new one.
+  aEntry->UpdateAttributes(std::move(aAttr));
+  // If the family name has changed, remove the entry from its current family
+  // and clear the mFamilyName field so it can be reset when added to a new
+  // family.
+  if (resetFamilyName) {
+    RefPtr<gfxUserFontFamily> family = LookupFamily(aEntry->mFamilyName);
+    if (family) {
+      family->RemoveFontEntry(aEntry);
+    }
+    aEntry->mFamilyName.Truncate(0);
+  }
+}
+
+class FontFaceSetImpl::UpdateUserFontEntryRunnable final
+    : public WorkerMainThreadRunnable {
+ public:
+  UpdateUserFontEntryRunnable(FontFaceSetImpl* aSet, gfxUserFontEntry* aEntry,
+                              gfxUserFontAttributes& aAttr)
+      : WorkerMainThreadRunnable(
+            GetCurrentThreadWorkerPrivate(),
+            "FontFaceSetImpl :: FindOrCreateUserFontEntryFromFontFace"_ns),
+        mSet(aSet),
+        mEntry(aEntry),
+        mAttr(aAttr) {}
+
+  bool MainThreadRun() override {
+    mSet->UpdateUserFontEntry(mEntry, std::move(mAttr));
+    return true;
+  }
+
+ private:
+  FontFaceSetImpl* mSet;
+  gfxUserFontEntry* mEntry;
+  gfxUserFontAttributes& mAttr;
+};
+
+// TODO(emilio): Should this take an nsAtom* aFamilyName instead?
+//
+// All callers have one handy.
+/* static */
+already_AddRefed<gfxUserFontEntry>
+FontFaceSetImpl::FindOrCreateUserFontEntryFromFontFace(
+    FontFaceImpl* aFontFace, gfxUserFontAttributes&& aAttr,
+    StyleOrigin aOrigin) {
+  FontFaceSetImpl* set = aFontFace->GetPrimaryFontFaceSet();
+
+  RefPtr<gfxUserFontEntry> existingEntry = aFontFace->GetUserFontEntry();
+  if (existingEntry) {
+    if (NS_IsMainThread()) {
+      set->UpdateUserFontEntry(existingEntry, std::move(aAttr));
+    } else {
+      auto task =
+          MakeRefPtr<UpdateUserFontEntryRunnable>(set, existingEntry, aAttr);
+      IgnoredErrorResult ignoredRv;
+      task->Dispatch(Canceling, ignoredRv);
+    }
+    return existingEntry.forget();
+  }
+
+  // set up src array
+  nsTArray<gfxFontFaceSrc> srcArray;
+
+  if (aFontFace->HasFontData()) {
+    gfxFontFaceSrc* face = srcArray.AppendElement();
+    if (!face) {
+      return nullptr;
+    }
+
+    face->mSourceType = gfxFontFaceSrc::eSourceType_Buffer;
+    face->mBuffer = aFontFace->TakeBufferSource();
+  } else {
+    size_t len = aAttr.mSources.Length();
+    for (size_t i = 0; i < len; ++i) {
+      gfxFontFaceSrc* face = srcArray.AppendElement();
+      const auto& component = aAttr.mSources[i];
+      switch (component.tag) {
+        case StyleFontFaceSourceListComponent::Tag::Local: {
+          nsAtom* atom = component.AsLocal();
+          face->mLocalName.Append(nsAtomCString(atom));
+          face->mSourceType = gfxFontFaceSrc::eSourceType_Local;
+          face->mURI = nullptr;
+          face->mFormatHint = StyleFontFaceSourceFormatKeyword::None;
+          break;
+        }
+
+        case StyleFontFaceSourceListComponent::Tag::Url: {
+          face->mSourceType = gfxFontFaceSrc::eSourceType_URL;
+          const StyleCssUrl* url = component.AsUrl();
+          nsIURI* uri = url->GetURI();
+          face->mURI = uri ? new gfxFontSrcURI(uri) : nullptr;
+          const URLExtraData& extraData = url->ExtraData();
+          face->mReferrerInfo = extraData.ReferrerInfo();
+
+          // agent and user stylesheets are treated slightly differently,
+          // the same-site origin check and access control headers are
+          // enforced against the sheet principal rather than the document
+          // principal to allow user stylesheets to include @font-face rules
+          if (aOrigin == StyleOrigin::User ||
+              aOrigin == StyleOrigin::UserAgent) {
+            face->mUseOriginPrincipal = true;
+            face->mOriginPrincipal = new gfxFontSrcPrincipal(
+                extraData.Principal(), extraData.Principal());
+          }
+
+          face->mLocalName.Truncate();
+          face->mFormatHint = StyleFontFaceSourceFormatKeyword::None;
+          face->mTechFlags = StyleFontFaceSourceTechFlags::Empty();
+
+          if (i + 1 < len) {
+            // Check for a format hint.
+            const auto& next = aAttr.mSources[i + 1];
+            switch (next.tag) {
+              case StyleFontFaceSourceListComponent::Tag::FormatHintKeyword:
+                face->mFormatHint = next.format_hint_keyword._0;
+                i++;
+                break;
+              case StyleFontFaceSourceListComponent::Tag::FormatHintString: {
+                nsDependentCSubstring valueString(
+                    reinterpret_cast<const char*>(
+                        next.format_hint_string.utf8_bytes),
+                    next.format_hint_string.length);
+
+                if (valueString.LowerCaseEqualsASCII("woff")) {
+                  face->mFormatHint = StyleFontFaceSourceFormatKeyword::Woff;
+                } else if (valueString.LowerCaseEqualsASCII("woff2")) {
+                  face->mFormatHint = StyleFontFaceSourceFormatKeyword::Woff2;
+                } else if (valueString.LowerCaseEqualsASCII("opentype")) {
+                  face->mFormatHint =
+                      StyleFontFaceSourceFormatKeyword::Opentype;
+                } else if (valueString.LowerCaseEqualsASCII("truetype")) {
+                  face->mFormatHint =
+                      StyleFontFaceSourceFormatKeyword::Truetype;
+                } else if (valueString.LowerCaseEqualsASCII("truetype-aat")) {
+                  face->mFormatHint =
+                      StyleFontFaceSourceFormatKeyword::Truetype;
+                } else if (valueString.LowerCaseEqualsASCII(
+                               "embedded-opentype")) {
+                  face->mFormatHint =
+                      StyleFontFaceSourceFormatKeyword::EmbeddedOpentype;
+                } else if (valueString.LowerCaseEqualsASCII("svg")) {
+                  face->mFormatHint = StyleFontFaceSourceFormatKeyword::Svg;
+                } else if (StaticPrefs::layout_css_font_variations_enabled()) {
+                  // Non-standard values that Firefox accepted, for back-compat;
+                  // these are superseded by the tech() function.
+                  if (valueString.LowerCaseEqualsASCII("woff-variations")) {
+                    face->mFormatHint = StyleFontFaceSourceFormatKeyword::Woff;
+                  } else if (valueString.LowerCaseEqualsASCII(
+                                 "woff2-variations")) {
+                    face->mFormatHint = StyleFontFaceSourceFormatKeyword::Woff2;
+                  } else if (valueString.LowerCaseEqualsASCII(
+                                 "opentype-variations")) {
+                    face->mFormatHint =
+                        StyleFontFaceSourceFormatKeyword::Opentype;
+                  } else if (valueString.LowerCaseEqualsASCII(
+                                 "truetype-variations")) {
+                    face->mFormatHint =
+                        StyleFontFaceSourceFormatKeyword::Truetype;
+                  } else {
+                    face->mFormatHint =
+                        StyleFontFaceSourceFormatKeyword::Unknown;
+                  }
+                } else {
+                  // unknown format specified, mark to distinguish from the
+                  // case where no format hints are specified
+                  face->mFormatHint = StyleFontFaceSourceFormatKeyword::Unknown;
+                }
+                i++;
+                break;
+              }
+              case StyleFontFaceSourceListComponent::Tag::TechFlags:
+              case StyleFontFaceSourceListComponent::Tag::Local:
+              case StyleFontFaceSourceListComponent::Tag::Url:
+                break;
+            }
+          }
+
+          if (i + 1 < len) {
+            // Check for a set of font-technologies flags.
+            const auto& next = aAttr.mSources[i + 1];
+            if (next.IsTechFlags()) {
+              face->mTechFlags = next.AsTechFlags();
+              i++;
+            }
+          }
+
+          if (!face->mURI) {
+            // if URI not valid, omit from src array
+            srcArray.RemoveLastElement();
+            NS_WARNING("null url in @font-face rule");
+            continue;
+          }
+          break;
+        }
+
+        case StyleFontFaceSourceListComponent::Tag::FormatHintKeyword:
+        case StyleFontFaceSourceListComponent::Tag::FormatHintString:
+        case StyleFontFaceSourceListComponent::Tag::TechFlags:
+          MOZ_ASSERT_UNREACHABLE(
+              "Should always come after a URL source, and be consumed already");
+          break;
+      }
+    }
+  }
+
+  if (srcArray.IsEmpty()) {
+    return nullptr;
+  }
+
+  return set->FindOrCreateUserFontEntry(std::move(srcArray), std::move(aAttr));
+}
+
+nsresult FontFaceSetImpl::LogMessage(gfxUserFontEntry* aUserFontEntry,
+                                     uint32_t aSrcIndex, const char* aMessage,
+                                     uint32_t aFlags, nsresult aStatus) {
+  nsAutoCString familyName;
+  nsAutoCString fontURI;
+  aUserFontEntry->GetFamilyNameAndURIForLogging(aSrcIndex, familyName, fontURI);
+
+  nsAutoCString weightString;
+  aUserFontEntry->Weight().ToString(weightString);
+  nsAutoCString stretchString;
+  aUserFontEntry->Stretch().ToString(stretchString);
+  nsPrintfCString message(
+      "downloadable font: %s "
+      "(font-family: \"%s\" style:%s weight:%s stretch:%s src index:%d)",
+      aMessage, familyName.get(),
+      aUserFontEntry->IsItalic() ? "italic" : "normal",  // XXX todo: oblique?
+      weightString.get(), stretchString.get(), aSrcIndex);
+
+  if (NS_FAILED(aStatus)) {
+    message.AppendLiteral(": ");
+    switch (aStatus) {
+      case NS_ERROR_DOM_BAD_URI:
+        message.AppendLiteral("bad URI or cross-site access not allowed");
+        break;
+      case NS_ERROR_CONTENT_BLOCKED:
+        message.AppendLiteral("content blocked");
+        break;
+      default:
+        message.AppendLiteral("status=");
+        message.AppendInt(static_cast<uint32_t>(aStatus));
+        break;
+    }
+  }
+  message.AppendLiteral(" source: ");
+  message.Append(fontURI);
+
+  LOG(("userfonts (%p) %s", this, message.get()));
+
+  if (GetCurrentThreadWorkerPrivate()) {
+    // TODO(aosmond): Log to the console for workers. See bug 1778537.
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIConsoleService> console(
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+  if (!console) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // try to give the user an indication of where the rule came from
+  StyleLockedFontFaceRule* rule = FindRuleForUserFontEntry(aUserFontEntry);
+  nsString href;
+  nsAutoCString text;
+  uint32_t line = 0;
+  uint32_t column = 0;
+  if (rule) {
+    Servo_FontFaceRule_GetCssText(rule, &text);
+    Servo_FontFaceRule_GetSourceLocation(rule, &line, &column);
+    // FIXME We need to figure out an approach to get the style sheet
+    // of this raw rule. See bug 1450903.
+#if 0
+    StyleSheet* sheet = rule->GetStyleSheet();
+    // if the style sheet is removed while the font is loading can be null
+    if (sheet) {
+      nsCString spec = sheet->GetSheetURI()->GetSpecOrDefault();
+      CopyUTF8toUTF16(spec, href);
+    } else {
+      NS_WARNING("null parent stylesheet for @font-face rule");
+      href.AssignLiteral("unknown");
+    }
+#endif
+    // Leave href empty if we don't know how to get the correct sheet.
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIScriptError> scriptError =
+      do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = scriptError->InitWithWindowID(NS_ConvertUTF8toUTF16(message),
+                                     href,                         // file
+                                     NS_ConvertUTF8toUTF16(text),  // src line
+                                     line, column,
+                                     aFlags,        // flags
+                                     "CSS Loader",  // category (make separate?)
+                                     GetInnerWindowID());
+  if (NS_SUCCEEDED(rv)) {
+    console->LogMessage(scriptError);
+  }
+
+  return NS_OK;
+}
+
+nsresult FontFaceSetImpl::SyncLoadFontData(gfxUserFontEntry* aFontToLoad,
+                                           const gfxFontFaceSrc* aFontFaceSrc,
+                                           uint8_t*& aBuffer,
+                                           uint32_t& aBufferLength) {
+  nsCOMPtr<nsIChannel> channel;
+  nsresult rv = CreateChannelForSyncLoadFontData(getter_AddRefs(channel),
+                                                 aFontToLoad, aFontFaceSrc);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // blocking stream is OK for data URIs
+  nsCOMPtr<nsIInputStream> stream;
+  rv = channel->Open(getter_AddRefs(stream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint64_t bufferLength64;
+  rv = stream->Available(&bufferLength64);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (bufferLength64 == 0) {
+    return NS_ERROR_FAILURE;
+  }
+  if (bufferLength64 > UINT32_MAX) {
+    return NS_ERROR_FILE_TOO_BIG;
+  }
+  aBufferLength = static_cast<uint32_t>(bufferLength64);
+
+  // read all the decoded data
+  aBuffer = static_cast<uint8_t*>(malloc(sizeof(uint8_t) * aBufferLength));
+  if (!aBuffer) {
+    aBufferLength = 0;
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  uint32_t numRead, totalRead = 0;
+  while (NS_SUCCEEDED(
+             rv = stream->Read(reinterpret_cast<char*>(aBuffer + totalRead),
+                               aBufferLength - totalRead, &numRead)) &&
+         numRead != 0) {
+    totalRead += numRead;
+    if (totalRead > aBufferLength) {
+      rv = NS_ERROR_FAILURE;
+      break;
+    }
+  }
+
+  // make sure there's a mime type
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString mimeType;
+    rv = channel->GetContentType(mimeType);
+    aBufferLength = totalRead;
+  }
+
+  if (NS_FAILED(rv)) {
+    free(aBuffer);
+    aBuffer = nullptr;
+    aBufferLength = 0;
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+void FontFaceSetImpl::OnFontFaceStatusChanged(FontFaceImpl* aFontFace) {
+  gfxFontUtils::AssertSafeThreadOrServoFontMetricsLocked();
+  RecursiveMutexAutoLock lock(mMutex);
+  MOZ_ASSERT(HasAvailableFontFace(aFontFace));
+
+  mHasLoadingFontFacesIsDirty = true;
+
+  if (aFontFace->Status() == FontFaceLoadStatus::Loading) {
+    CheckLoadingStarted();
+  } else {
+    MOZ_ASSERT(aFontFace->Status() == FontFaceLoadStatus::Loaded ||
+               aFontFace->Status() == FontFaceLoadStatus::Error);
+    // When a font finishes downloading, nsPresContext::UserFontSetUpdated
+    // will be called immediately afterwards to request a reflow of the
+    // relevant elements in the document.  We want to wait until the reflow
+    // request has been done before the FontFaceSet is marked as Loaded so
+    // that we don't briefly set the FontFaceSet to Loaded and then Loading
+    // again once the reflow is pending.  So we go around the event loop
+    // and call CheckLoadingFinished() after the reflow has been queued.
+    if (!mDelayedLoadCheck) {
+      mDelayedLoadCheck = true;
+      DispatchCheckLoadingFinishedAfterDelay();
+    }
+  }
+}
+
+void FontFaceSetImpl::DispatchCheckLoadingFinishedAfterDelay() {
+  gfxFontUtils::AssertSafeThreadOrServoFontMetricsLocked();
+
+  if (ServoStyleSet* set = gfxFontUtils::CurrentServoStyleSet()) {
+    // See comments in Gecko_GetFontMetrics.
+    //
+    // We can't just dispatch the runnable below if we're not on the main
+    // thread, since it needs to take a strong reference to the FontFaceSet,
+    // and being a DOM object, FontFaceSet doesn't support thread-safe
+    // refcounting.
+    set->AppendTask(
+        PostTraversalTask::DispatchFontFaceSetCheckLoadingFinishedAfterDelay(
+            this));
+    return;
+  }
+
+  DispatchToOwningThread(
+      "FontFaceSetImpl::DispatchCheckLoadingFinishedAfterDelay",
+      [self = RefPtr{this}]() { self->CheckLoadingFinishedAfterDelay(); });
+}
+
+void FontFaceSetImpl::CheckLoadingFinishedAfterDelay() {
+  RecursiveMutexAutoLock lock(mMutex);
+  mDelayedLoadCheck = false;
+  CheckLoadingFinished();
+}
+
+void FontFaceSetImpl::CheckLoadingStarted() {
+  gfxFontUtils::AssertSafeThreadOrServoFontMetricsLocked();
+  RecursiveMutexAutoLock lock(mMutex);
+
+  if (!HasLoadingFontFaces()) {
+    return;
+  }
+
+  if (mStatus == FontFaceSetLoadStatus::Loading) {
+    // We have already dispatched a loading event and replaced mReady
+    // with a fresh, unresolved promise.
+    return;
+  }
+
+  mStatus = FontFaceSetLoadStatus::Loading;
+
+  if (IsOnOwningThread()) {
+    OnLoadingStarted();
+    return;
+  }
+
+  DispatchToOwningThread("FontFaceSetImpl::CheckLoadingStarted",
+                         [self = RefPtr{this}]() { self->OnLoadingStarted(); });
+}
+
+void FontFaceSetImpl::OnLoadingStarted() {
+  RecursiveMutexAutoLock lock(mMutex);
+  if (mOwner) {
+    mOwner->DispatchLoadingEventAndReplaceReadyPromise();
+  }
+}
+
+void FontFaceSetImpl::UpdateHasLoadingFontFaces() {
+  RecursiveMutexAutoLock lock(mMutex);
+  mHasLoadingFontFacesIsDirty = false;
+  mHasLoadingFontFaces = false;
+  for (size_t i = 0; i < mNonRuleFaces.Length(); i++) {
+    if (mNonRuleFaces[i].mFontFace->Status() == FontFaceLoadStatus::Loading) {
+      mHasLoadingFontFaces = true;
+      return;
+    }
+  }
+}
+
+bool FontFaceSetImpl::HasLoadingFontFaces() {
+  RecursiveMutexAutoLock lock(mMutex);
+  if (mHasLoadingFontFacesIsDirty) {
+    UpdateHasLoadingFontFaces();
+  }
+  return mHasLoadingFontFaces;
+}
+
+bool FontFaceSetImpl::MightHavePendingFontLoads() {
+  // Check for FontFace objects in the FontFaceSet that are still loading.
+  return HasLoadingFontFaces();
+}
+
+void FontFaceSetImpl::CheckLoadingFinished() {
+  RecursiveMutexAutoLock lock(mMutex);
+  if (mDelayedLoadCheck) {
+    // Wait until the runnable posted in OnFontFaceStatusChanged calls us.
+    return;
+  }
+
+  if (!ReadyPromiseIsPending()) {
+    // We've already resolved mReady (or set the flag to do that lazily) and
+    // dispatched the loadingdone/loadingerror events.
+    return;
+  }
+
+  if (MightHavePendingFontLoads()) {
+    // We're not finished loading yet.
+    return;
+  }
+
+  mStatus = FontFaceSetLoadStatus::Loaded;
+
+  if (IsOnOwningThread()) {
+    OnLoadingFinished();
+    return;
+  }
+
+  DispatchToOwningThread(
+      "FontFaceSetImpl::CheckLoadingFinished",
+      [self = RefPtr{this}]() { self->OnLoadingFinished(); });
+}
+
+void FontFaceSetImpl::OnLoadingFinished() {
+  RecursiveMutexAutoLock lock(mMutex);
+  if (mOwner) {
+    mOwner->MaybeResolve();
+  }
+}
+
+void FontFaceSetImpl::RefreshStandardFontLoadPrincipal() {
+  RecursiveMutexAutoLock lock(mMutex);
+  mAllowedFontLoads.Clear();
+  IncrementGeneration(false);
+}
+
+// -- gfxUserFontSet
+// ------------------------------------------------
+
+already_AddRefed<gfxFontSrcPrincipal>
+FontFaceSetImpl::GetStandardFontLoadPrincipal() const {
+  RecursiveMutexAutoLock lock(mMutex);
+  return RefPtr{mStandardFontLoadPrincipal}.forget();
+}
+
+void FontFaceSetImpl::RecordFontLoadDone(uint32_t aFontSize,
+                                         TimeStamp aDoneTime) {
+  mDownloadCount++;
+  mDownloadSize += aFontSize;
+  Telemetry::Accumulate(Telemetry::WEBFONT_SIZE, aFontSize / 1024);
+
+  TimeStamp navStart = GetNavigationStartTimeStamp();
+  TimeStamp zero;
+  if (navStart != zero) {
+    Telemetry::AccumulateTimeDelta(Telemetry::WEBFONT_DOWNLOAD_TIME_AFTER_START,
+                                   navStart, aDoneTime);
+  }
+}
+
+void FontFaceSetImpl::DoRebuildUserFontSet() { MarkUserFontSetDirty(); }
+
+already_AddRefed<gfxUserFontEntry> FontFaceSetImpl::CreateUserFontEntry(
+    nsTArray<gfxFontFaceSrc>&& aFontFaceSrcList,
+    gfxUserFontAttributes&& aAttr) {
+  RefPtr<gfxUserFontEntry> entry = new FontFaceImpl::Entry(
+      this, std::move(aFontFaceSrcList), std::move(aAttr));
+  return entry.forget();
+}
+
+void FontFaceSetImpl::ForgetLocalFaces() {
+  // We cannot hold our lock at the same time as the gfxUserFontFamily lock, so
+  // we need to make a copy of the table first.
+  nsTArray<RefPtr<gfxUserFontFamily>> fontFamilies;
+  {
+    RecursiveMutexAutoLock lock(mMutex);
+    fontFamilies.SetCapacity(mFontFamilies.Count());
+    for (const auto& fam : mFontFamilies.Values()) {
+      fontFamilies.AppendElement(fam);
+    }
+  }
+
+  for (const auto& fam : fontFamilies) {
+    ForgetLocalFace(fam);
+  }
+}
+
+already_AddRefed<gfxUserFontFamily> FontFaceSetImpl::GetFamily(
+    const nsACString& aFamilyName) {
+  RecursiveMutexAutoLock lock(mMutex);
+  return gfxUserFontSet::GetFamily(aFamilyName);
+}
+
+#undef LOG_ENABLED
+#undef LOG