summaryrefslogtreecommitdiffstats
path: root/layout/style/FontFaceSet.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/style/FontFaceSet.cpp')
-rw-r--r--layout/style/FontFaceSet.cpp1848
1 files changed, 1848 insertions, 0 deletions
diff --git a/layout/style/FontFaceSet.cpp b/layout/style/FontFaceSet.cpp
new file mode 100644
index 000000000..59626fba4
--- /dev/null
+++ b/layout/style/FontFaceSet.cpp
@@ -0,0 +1,1848 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=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 "FontFaceSet.h"
+
+#include "gfxFontConstants.h"
+#include "mozilla/css/Declaration.h"
+#include "mozilla/css/Loader.h"
+#include "mozilla/dom/FontFaceSetBinding.h"
+#include "mozilla/dom/FontFaceSetIterator.h"
+#include "mozilla/dom/FontFaceSetLoadEvent.h"
+#include "mozilla/dom/FontFaceSetLoadEventBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/SizePrintfMacros.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/Telemetry.h"
+#include "nsAutoPtr.h"
+#include "nsContentPolicyUtils.h"
+#include "nsCSSParser.h"
+#include "nsDeviceContext.h"
+#include "nsFontFaceLoader.h"
+#include "nsIConsoleService.h"
+#include "nsIContentPolicy.h"
+#include "nsIContentSecurityPolicy.h"
+#include "nsIDocShell.h"
+#include "nsIDocument.h"
+#include "nsINetworkPredictor.h"
+#include "nsIPresShell.h"
+#include "nsIPrincipal.h"
+#include "nsISupportsPriority.h"
+#include "nsIWebNavigation.h"
+#include "nsNetUtil.h"
+#include "nsIProtocolHandler.h"
+#include "nsIInputStream.h"
+#include "nsPresContext.h"
+#include "nsPrintfCString.h"
+#include "nsStyleSet.h"
+#include "nsUTF8Utils.h"
+#include "nsDOMNavigationTiming.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)
+
+#define FONT_LOADING_API_ENABLED_PREF "layout.css.font-loading-api.enabled"
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(FontFaceSet)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(FontFaceSet, DOMEventTargetHelper)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument);
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReady);
+ for (size_t i = 0; i < tmp->mRuleFaces.Length(); i++) {
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRuleFaces[i].mFontFace);
+ }
+ for (size_t i = 0; i < tmp->mNonRuleFaces.Length(); i++) {
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNonRuleFaces[i].mFontFace);
+ }
+ if (tmp->mUserFontSet) {
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUserFontSet->mFontFaceSet);
+ }
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(FontFaceSet, DOMEventTargetHelper)
+ tmp->Disconnect();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument);
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mReady);
+ for (size_t i = 0; i < tmp->mRuleFaces.Length(); i++) {
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mRuleFaces[i].mFontFace);
+ }
+ for (size_t i = 0; i < tmp->mNonRuleFaces.Length(); i++) {
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mNonRuleFaces[i].mFontFace);
+ }
+ if (tmp->mUserFontSet) {
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mUserFontSet->mFontFaceSet);
+ }
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mUserFontSet);
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_ADDREF_INHERITED(FontFaceSet, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(FontFaceSet, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(FontFaceSet)
+ NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+ NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+FontFaceSet::FontFaceSet(nsPIDOMWindowInner* aWindow, nsIDocument* aDocument)
+ : DOMEventTargetHelper(aWindow)
+ , mDocument(aDocument)
+ , mResolveLazilyCreatedReadyPromise(false)
+ , mStatus(FontFaceSetLoadStatus::Loaded)
+ , mNonRuleFacesDirty(false)
+ , mHasLoadingFontFaces(false)
+ , mHasLoadingFontFacesIsDirty(false)
+ , mDelayedLoadCheck(false)
+{
+ MOZ_COUNT_CTOR(FontFaceSet);
+
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aWindow);
+
+ // If the pref is not set, don't create the Promise (which the page wouldn't
+ // be able to get to anyway) as it causes the window.FontFaceSet constructor
+ // to be created.
+ if (global && PrefEnabled()) {
+ mResolveLazilyCreatedReadyPromise = true;
+ }
+
+ if (!mDocument->DidFireDOMContentLoaded()) {
+ mDocument->AddSystemEventListener(NS_LITERAL_STRING("DOMContentLoaded"),
+ this, false, false);
+ }
+
+ mDocument->CSSLoader()->AddObserver(this);
+
+ mUserFontSet = new UserFontSet(this);
+}
+
+FontFaceSet::~FontFaceSet()
+{
+ MOZ_COUNT_DTOR(FontFaceSet);
+
+ Disconnect();
+ for (auto it = mLoaders.Iter(); !it.Done(); it.Next()) {
+ it.Get()->GetKey()->Cancel();
+ }
+}
+
+JSObject*
+FontFaceSet::WrapObject(JSContext* aContext, JS::Handle<JSObject*> aGivenProto)
+{
+ return FontFaceSetBinding::Wrap(aContext, this, aGivenProto);
+}
+
+void
+FontFaceSet::Disconnect()
+{
+ RemoveDOMContentLoadedListener();
+
+ if (mDocument && mDocument->CSSLoader()) {
+ // We're null checking CSSLoader() since FontFaceSet::Disconnect() might be
+ // being called during unlink, at which time the loader amy already have
+ // been unlinked from the document.
+ mDocument->CSSLoader()->RemoveObserver(this);
+ }
+}
+
+void
+FontFaceSet::RemoveDOMContentLoadedListener()
+{
+ if (mDocument) {
+ mDocument->RemoveSystemEventListener(NS_LITERAL_STRING("DOMContentLoaded"),
+ this, false);
+ }
+}
+
+void
+FontFaceSet::ParseFontShorthandForMatching(
+ const nsAString& aFont,
+ RefPtr<FontFamilyListRefCnt>& aFamilyList,
+ uint32_t& aWeight,
+ int32_t& aStretch,
+ uint8_t& aStyle,
+ ErrorResult& aRv)
+{
+ // Parse aFont as a 'font' property value.
+ RefPtr<Declaration> declaration = new Declaration;
+ declaration->InitializeEmpty();
+
+ bool changed = false;
+ nsCSSParser parser;
+ parser.ParseProperty(eCSSProperty_font,
+ aFont,
+ mDocument->GetDocumentURI(),
+ mDocument->GetDocumentURI(),
+ mDocument->NodePrincipal(),
+ declaration,
+ &changed,
+ /* aIsImportant */ false);
+
+ // All of the properties we are interested in should have been set at once.
+ MOZ_ASSERT(changed == (declaration->HasProperty(eCSSProperty_font_family) &&
+ declaration->HasProperty(eCSSProperty_font_style) &&
+ declaration->HasProperty(eCSSProperty_font_weight) &&
+ declaration->HasProperty(eCSSProperty_font_stretch)));
+
+ if (!changed) {
+ aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+ return;
+ }
+
+ nsCSSCompressedDataBlock* data = declaration->GetNormalBlock();
+ MOZ_ASSERT(!declaration->GetImportantBlock());
+
+ const nsCSSValue* family = data->ValueFor(eCSSProperty_font_family);
+ if (family->GetUnit() != eCSSUnit_FontFamilyList) {
+ // We got inherit, initial, unset, a system font, or a token stream.
+ aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+ return;
+ }
+
+ aFamilyList =
+ static_cast<FontFamilyListRefCnt*>(family->GetFontFamilyListValue());
+
+ int32_t weight = data->ValueFor(eCSSProperty_font_weight)->GetIntValue();
+
+ // Resolve relative font weights against the initial of font-weight
+ // (normal, which is equivalent to 400).
+ if (weight == NS_STYLE_FONT_WEIGHT_BOLDER) {
+ weight = NS_FONT_WEIGHT_BOLD;
+ } else if (weight == NS_STYLE_FONT_WEIGHT_LIGHTER) {
+ weight = NS_FONT_WEIGHT_THIN;
+ }
+
+ aWeight = weight;
+
+ aStretch = data->ValueFor(eCSSProperty_font_stretch)->GetIntValue();
+ aStyle = data->ValueFor(eCSSProperty_font_style)->GetIntValue();
+}
+
+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
+FontFaceSet::FindMatchingFontFaces(const nsAString& aFont,
+ const nsAString& aText,
+ nsTArray<FontFace*>& aFontFaces,
+ ErrorResult& aRv)
+{
+ RefPtr<FontFamilyListRefCnt> familyList;
+ uint32_t weight;
+ int32_t stretch;
+ uint8_t italicStyle;
+ ParseFontShorthandForMatching(aFont, familyList, weight, stretch, italicStyle,
+ aRv);
+ if (aRv.Failed()) {
+ return;
+ }
+
+ gfxFontStyle style;
+ style.style = italicStyle;
+ style.weight = weight;
+ style.stretch = stretch;
+
+ nsTArray<FontFaceRecord>* arrays[2];
+ arrays[0] = &mNonRuleFaces;
+ arrays[1] = &mRuleFaces;
+
+ // Set of FontFaces that we want to return.
+ nsTHashtable<nsPtrHashKey<FontFace>> matchingFaces;
+
+ for (const FontFamilyName& fontFamilyName : familyList->GetFontlist()) {
+ RefPtr<gfxFontFamily> family =
+ mUserFontSet->LookupFamily(fontFamilyName.mName);
+
+ if (!family) {
+ continue;
+ }
+
+ AutoTArray<gfxFontEntry*,4> entries;
+ bool needsBold;
+ family->FindAllFontsForStyle(style, entries, needsBold);
+
+ for (gfxFontEntry* e : entries) {
+ FontFace::Entry* entry = static_cast<FontFace::Entry*>(e);
+ if (HasAnyCharacterInUnicodeRange(entry, aText)) {
+ for (FontFace* f : entry->GetFontFaces()) {
+ matchingFaces.PutEntry(f);
+ }
+ }
+ }
+ }
+
+ // Add all FontFaces in matchingFaces to aFontFaces, in the order
+ // they appear in the FontFaceSet.
+ for (nsTArray<FontFaceRecord>* array : arrays) {
+ for (FontFaceRecord& record : *array) {
+ FontFace* f = record.mFontFace;
+ if (matchingFaces.Contains(f)) {
+ aFontFaces.AppendElement(f);
+ }
+ }
+ }
+}
+
+TimeStamp
+FontFaceSet::GetNavigationStartTimeStamp()
+{
+ TimeStamp navStart;
+ RefPtr<nsDOMNavigationTiming> timing(mDocument->GetNavigationTiming());
+ if (timing) {
+ navStart = timing->GetNavigationStartTimeStamp();
+ }
+ return navStart;
+}
+
+already_AddRefed<Promise>
+FontFaceSet::Load(JSContext* aCx,
+ const nsAString& aFont,
+ const nsAString& aText,
+ ErrorResult& aRv)
+{
+ FlushUserFontSet();
+
+ nsTArray<RefPtr<Promise>> promises;
+
+ nsTArray<FontFace*> faces;
+ FindMatchingFontFaces(aFont, aText, faces, aRv);
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+
+ for (FontFace* f : faces) {
+ RefPtr<Promise> promise = f->Load(aRv);
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+ if (!promises.AppendElement(promise, fallible)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ }
+
+ nsIGlobalObject* globalObject = GetParentObject();
+ if (!globalObject) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ JS::Rooted<JSObject*> jsGlobal(aCx, globalObject->GetGlobalJSObject());
+ GlobalObject global(aCx, jsGlobal);
+
+ RefPtr<Promise> result = Promise::All(global, promises, aRv);
+ return result.forget();
+}
+
+bool
+FontFaceSet::Check(const nsAString& aFont,
+ const nsAString& aText,
+ ErrorResult& aRv)
+{
+ FlushUserFontSet();
+
+ nsTArray<FontFace*> faces;
+ FindMatchingFontFaces(aFont, aText, faces, aRv);
+ if (aRv.Failed()) {
+ return false;
+ }
+
+ for (FontFace* f : faces) {
+ if (f->Status() != FontFaceLoadStatus::Loaded) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+Promise*
+FontFaceSet::GetReady(ErrorResult& aRv)
+{
+ if (!mReady) {
+ nsCOMPtr<nsIGlobalObject> global = GetParentObject();
+ mReady = Promise::Create(global, aRv);
+ if (!mReady) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ if (mResolveLazilyCreatedReadyPromise) {
+ mReady->MaybeResolve(this);
+ mResolveLazilyCreatedReadyPromise = false;
+ }
+ }
+
+ FlushUserFontSet();
+ return mReady;
+}
+
+FontFaceSetLoadStatus
+FontFaceSet::Status()
+{
+ FlushUserFontSet();
+ return mStatus;
+}
+
+#ifdef DEBUG
+bool
+FontFaceSet::HasRuleFontFace(FontFace* aFontFace)
+{
+ for (size_t i = 0; i < mRuleFaces.Length(); i++) {
+ if (mRuleFaces[i].mFontFace == aFontFace) {
+ return true;
+ }
+ }
+ return false;
+}
+#endif
+
+FontFaceSet*
+FontFaceSet::Add(FontFace& aFontFace, ErrorResult& aRv)
+{
+ FlushUserFontSet();
+
+ if (aFontFace.IsInFontFaceSet(this)) {
+ return this;
+ }
+
+ if (aFontFace.HasRule()) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_MODIFICATION_ERR);
+ return nullptr;
+ }
+
+ 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->mSheetType = SheetType::Unknown; // unused for mNonRuleFaces
+ rec->mLoadEventShouldFire =
+ aFontFace.Status() == FontFaceLoadStatus::Unloaded ||
+ aFontFace.Status() == FontFaceLoadStatus::Loading;
+
+ mNonRuleFacesDirty = true;
+ RebuildUserFontSet();
+ mHasLoadingFontFacesIsDirty = true;
+ CheckLoadingStarted();
+ return this;
+}
+
+void
+FontFaceSet::Clear()
+{
+ FlushUserFontSet();
+
+ if (mNonRuleFaces.IsEmpty()) {
+ return;
+ }
+
+ for (size_t i = 0; i < mNonRuleFaces.Length(); i++) {
+ FontFace* f = mNonRuleFaces[i].mFontFace;
+ f->RemoveFontFaceSet(this);
+ }
+
+ mNonRuleFaces.Clear();
+ mNonRuleFacesDirty = true;
+ RebuildUserFontSet();
+ mHasLoadingFontFacesIsDirty = true;
+ CheckLoadingFinished();
+}
+
+bool
+FontFaceSet::Delete(FontFace& aFontFace)
+{
+ 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;
+ RebuildUserFontSet();
+ mHasLoadingFontFacesIsDirty = true;
+ CheckLoadingFinished();
+ return true;
+}
+
+bool
+FontFaceSet::HasAvailableFontFace(FontFace* aFontFace)
+{
+ return aFontFace->IsInFontFaceSet(this);
+}
+
+bool
+FontFaceSet::Has(FontFace& aFontFace)
+{
+ FlushUserFontSet();
+
+ return HasAvailableFontFace(&aFontFace);
+}
+
+FontFace*
+FontFaceSet::GetFontFaceAt(uint32_t aIndex)
+{
+ FlushUserFontSet();
+
+ if (aIndex < mRuleFaces.Length()) {
+ return mRuleFaces[aIndex].mFontFace;
+ }
+
+ aIndex -= mRuleFaces.Length();
+ if (aIndex < mNonRuleFaces.Length()) {
+ return mNonRuleFaces[aIndex].mFontFace;
+ }
+
+ return nullptr;
+}
+
+uint32_t
+FontFaceSet::Size()
+{
+ FlushUserFontSet();
+
+ // Web IDL objects can only expose array index properties up to INT32_MAX.
+
+ size_t total = mRuleFaces.Length() + mNonRuleFaces.Length();
+ return std::min<size_t>(total, INT32_MAX);
+}
+
+already_AddRefed<FontFaceSetIterator>
+FontFaceSet::Entries()
+{
+ RefPtr<FontFaceSetIterator> it = new FontFaceSetIterator(this, true);
+ return it.forget();
+}
+
+already_AddRefed<FontFaceSetIterator>
+FontFaceSet::Values()
+{
+ RefPtr<FontFaceSetIterator> it = new FontFaceSetIterator(this, false);
+ return it.forget();
+}
+
+void
+FontFaceSet::ForEach(JSContext* aCx,
+ FontFaceSetForEachCallback& aCallback,
+ JS::Handle<JS::Value> aThisArg,
+ ErrorResult& aRv)
+{
+ JS::Rooted<JS::Value> thisArg(aCx, aThisArg);
+ for (size_t i = 0; i < Size(); i++) {
+ FontFace* face = GetFontFaceAt(i);
+ aCallback.Call(thisArg, *face, *face, *this, aRv);
+ if (aRv.Failed()) {
+ return;
+ }
+ }
+}
+
+void
+FontFaceSet::RemoveLoader(nsFontFaceLoader* aLoader)
+{
+ mLoaders.RemoveEntry(aLoader);
+}
+
+nsresult
+FontFaceSet::StartLoad(gfxUserFontEntry* aUserFontEntry,
+ const gfxFontFaceSrc* aFontFaceSrc)
+{
+ nsresult rv;
+
+ nsCOMPtr<nsIStreamLoader> streamLoader;
+ nsCOMPtr<nsILoadGroup> loadGroup(mDocument->GetDocumentLoadGroup());
+
+ nsCOMPtr<nsIChannel> channel;
+ // Note we are calling NS_NewChannelWithTriggeringPrincipal() with both a
+ // node and a principal. This is because the document where the font is
+ // being loaded might have a different origin from the principal of the
+ // stylesheet that initiated the font load.
+ rv = NS_NewChannelWithTriggeringPrincipal(getter_AddRefs(channel),
+ aFontFaceSrc->mURI,
+ mDocument,
+ aUserFontEntry->GetPrincipal(),
+ nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS,
+ nsIContentPolicy::TYPE_FONT,
+ loadGroup);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<nsFontFaceLoader> fontLoader =
+ new nsFontFaceLoader(aUserFontEntry, aFontFaceSrc->mURI, this, channel);
+
+ if (LOG_ENABLED()) {
+ LOG(("userfonts (%p) download start - font uri: (%s) "
+ "referrer uri: (%s)\n",
+ fontLoader.get(), aFontFaceSrc->mURI->GetSpecOrDefault().get(),
+ aFontFaceSrc->mReferrer
+ ? aFontFaceSrc->mReferrer->GetSpecOrDefault().get()
+ : ""));
+ }
+
+ nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
+ if (httpChannel) {
+ httpChannel->SetReferrerWithPolicy(aFontFaceSrc->mReferrer,
+ mDocument->GetReferrerPolicy());
+ nsAutoCString accept("application/font-woff;q=0.9,*/*;q=0.8");
+ if (Preferences::GetBool(GFX_PREF_WOFF2_ENABLED)) {
+ accept.Insert(NS_LITERAL_CSTRING("application/font-woff2;q=1.0,"), 0);
+ }
+ httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"),
+ accept, false);
+ // For WOFF and WOFF2, we should tell servers/proxies/etc NOT to try
+ // and apply additional compression at the content-encoding layer
+ if (aFontFaceSrc->mFormatFlags & (gfxUserFontSet::FLAG_FORMAT_WOFF |
+ gfxUserFontSet::FLAG_FORMAT_WOFF2)) {
+ httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept-Encoding"),
+ NS_LITERAL_CSTRING("identity"), false);
+ }
+ }
+ nsCOMPtr<nsISupportsPriority> priorityChannel(do_QueryInterface(channel));
+ if (priorityChannel) {
+ priorityChannel->AdjustPriority(nsISupportsPriority::PRIORITY_HIGH);
+ }
+
+ rv = NS_NewStreamLoader(getter_AddRefs(streamLoader), fontLoader);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mozilla::net::PredictorLearn(aFontFaceSrc->mURI, mDocument->GetDocumentURI(),
+ nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE,
+ loadGroup);
+
+ rv = channel->AsyncOpen2(streamLoader);
+ if (NS_FAILED(rv)) {
+ fontLoader->DropChannel(); // explicitly need to break ref cycle
+ }
+
+ if (NS_SUCCEEDED(rv)) {
+ mLoaders.PutEntry(fontLoader);
+ fontLoader->StartedLoading(streamLoader);
+ aUserFontEntry->SetLoader(fontLoader); // let the font entry remember the
+ // loader, in case we need to cancel it
+ }
+
+ return rv;
+}
+
+bool
+FontFaceSet::UpdateRules(const nsTArray<nsFontFaceRuleContainer>& aRules)
+{
+ MOZ_ASSERT(mUserFontSet);
+
+ // If there was a change to the mNonRuleFaces array, then there could
+ // have been a modification to the user font set.
+ bool modified = mNonRuleFacesDirty;
+ mNonRuleFacesDirty = false;
+
+ // reuse existing FontFace objects mapped to rules already
+ nsDataHashtable<nsPtrHashKey<nsCSSFontFaceRule>, FontFace*> ruleFaceMap;
+ for (size_t i = 0, i_end = mRuleFaces.Length(); i < i_end; ++i) {
+ FontFace* f = mRuleFaces[i].mFontFace;
+ if (!f) {
+ continue;
+ }
+ ruleFaceMap.Put(f->GetRule(), f);
+ }
+
+ // The @font-face rules that make up the user font set have changed,
+ // so we need to update the set. However, we want to preserve existing
+ // font entries wherever possible, so that we don't discard and then
+ // re-download resources in the (common) case where at least some of the
+ // same rules are still present.
+
+ nsTArray<FontFaceRecord> oldRecords;
+ mRuleFaces.SwapElements(oldRecords);
+
+ // Remove faces from the font family records; we need to re-insert them
+ // because we might end up with faces in a different order even if they're
+ // the same font entries as before. (The order can affect font selection
+ // where multiple faces match the requested style, perhaps with overlapping
+ // unicode-range coverage.)
+ for (auto it = mUserFontSet->mFontFamilies.Iter(); !it.Done(); it.Next()) {
+ it.Data()->DetachFontEntries();
+ }
+
+ // Sometimes aRules has duplicate @font-face rules in it; we should make
+ // that not happen, but in the meantime, don't try to insert the same
+ // FontFace object more than once into mRuleFaces. We track which
+ // ones we've handled in this table.
+ nsTHashtable<nsPtrHashKey<nsCSSFontFaceRule>> handledRules;
+
+ for (size_t i = 0, i_end = aRules.Length(); i < i_end; ++i) {
+ // Insert each FontFace objects for each rule into our list, migrating old
+ // font entries if possible rather than creating new ones; set modified to
+ // true if we detect that rule ordering has changed, or if a new entry is
+ // created.
+ if (handledRules.Contains(aRules[i].mRule)) {
+ continue;
+ }
+ nsCSSFontFaceRule* rule = aRules[i].mRule;
+ RefPtr<FontFace> f = ruleFaceMap.Get(rule);
+ if (!f.get()) {
+ f = FontFace::CreateForRule(GetParentObject(), this, rule);
+ }
+ InsertRuleFontFace(f, aRules[i].mSheetType, oldRecords, modified);
+ handledRules.PutEntry(aRules[i].mRule);
+ }
+
+ for (size_t i = 0, i_end = mNonRuleFaces.Length(); i < i_end; ++i) {
+ // Do the same for the non rule backed FontFace objects.
+ InsertNonRuleFontFace(mNonRuleFaces[i].mFontFace, modified);
+ }
+
+ // Remove any residual families that have no font entries (i.e., they were
+ // not defined at all by the updated set of @font-face rules).
+ for (auto it = mUserFontSet->mFontFamilies.Iter(); !it.Done(); it.Next()) {
+ if (it.Data()->GetFontList().IsEmpty()) {
+ it.Remove();
+ }
+ }
+
+ // If any FontFace objects for rules are left in the old list, note that the
+ // set has changed (even if the new set was built entirely by migrating old
+ // font entries).
+ if (oldRecords.Length() > 0) {
+ modified = true;
+ // Any in-progress loaders for obsolete rules should be cancelled,
+ // as the resource being downloaded will no longer be required.
+ // We need to explicitly remove any loaders here, otherwise the loaders
+ // will keep their "orphaned" font entries alive until they complete,
+ // even after the oldRules array is deleted.
+ //
+ // XXX Now that it is possible for the author to hold on to a rule backed
+ // FontFace object, we shouldn't cancel loading here; instead we should do
+ // it when the FontFace is GCed, if we can detect that.
+ size_t count = oldRecords.Length();
+ for (size_t i = 0; i < count; ++i) {
+ RefPtr<FontFace> f = oldRecords[i].mFontFace;
+ gfxUserFontEntry* userFontEntry = f->GetUserFontEntry();
+ if (userFontEntry) {
+ nsFontFaceLoader* loader = userFontEntry->GetLoader();
+ if (loader) {
+ loader->Cancel();
+ RemoveLoader(loader);
+ }
+ }
+
+ // Any left over FontFace objects should also cease being rule backed.
+ f->DisconnectFromRule();
+ }
+ }
+
+ if (modified) {
+ IncrementGeneration(true);
+ mHasLoadingFontFacesIsDirty = true;
+ CheckLoadingStarted();
+ CheckLoadingFinished();
+ }
+
+ // if local rules needed to be rebuilt, they have been rebuilt at this point
+ if (mUserFontSet->mRebuildLocalRules) {
+ mUserFontSet->mLocalRulesUsed = false;
+ mUserFontSet->mRebuildLocalRules = false;
+ }
+
+ if (LOG_ENABLED() && !mRuleFaces.IsEmpty()) {
+ LOG(("userfonts (%p) userfont rules update (%s) rule count: %d",
+ mUserFontSet.get(),
+ (modified ? "modified" : "not modified"),
+ (int)(mRuleFaces.Length())));
+ }
+
+ return modified;
+}
+
+static bool
+HasLocalSrc(const nsCSSValue::Array *aSrcArr)
+{
+ size_t numSrc = aSrcArr->Count();
+ for (size_t i = 0; i < numSrc; i++) {
+ if (aSrcArr->Item(i).GetUnit() == eCSSUnit_Local_Font) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void
+FontFaceSet::IncrementGeneration(bool aIsRebuild)
+{
+ MOZ_ASSERT(mUserFontSet);
+ mUserFontSet->IncrementGeneration(aIsRebuild);
+}
+
+void
+FontFaceSet::InsertNonRuleFontFace(FontFace* aFontFace,
+ bool& aFontSetModified)
+{
+ nsAutoString fontfamily;
+ if (!aFontFace->GetFamilyName(fontfamily)) {
+ // If there is no family name, this rule cannot contribute a
+ // usable font, so there is no point in processing it further.
+ return;
+ }
+
+ // Just create a new font entry if we haven't got one already.
+ if (!aFontFace->GetUserFontEntry()) {
+ // XXX Should we be checking mUserFontSet->mLocalRulesUsed like
+ // InsertRuleFontFace does?
+ RefPtr<gfxUserFontEntry> entry =
+ FindOrCreateUserFontEntryFromFontFace(fontfamily, aFontFace,
+ SheetType::Doc);
+ if (!entry) {
+ return;
+ }
+ aFontFace->SetUserFontEntry(entry);
+ }
+
+ aFontSetModified = true;
+ mUserFontSet->AddUserFontEntry(fontfamily, aFontFace->GetUserFontEntry());
+}
+
+void
+FontFaceSet::InsertRuleFontFace(FontFace* aFontFace, SheetType aSheetType,
+ nsTArray<FontFaceRecord>& aOldRecords,
+ bool& aFontSetModified)
+{
+ nsAutoString fontfamily;
+ if (!aFontFace->GetFamilyName(fontfamily)) {
+ // If there is no family name, this rule cannot contribute a
+ // usable font, so there is no point in processing it further.
+ return;
+ }
+
+ bool remove = false;
+ size_t removeIndex;
+
+ // This is a rule backed FontFace. First, we check in aOldRecords; if
+ // the FontFace for the rule exists there, just move it to the new record
+ // list, and put the entry into the appropriate family.
+ for (size_t i = 0; i < aOldRecords.Length(); ++i) {
+ FontFaceRecord& rec = aOldRecords[i];
+
+ if (rec.mFontFace == aFontFace &&
+ rec.mSheetType == aSheetType) {
+
+ // if local rules were used, don't use the old font entry
+ // for rules containing src local usage
+ if (mUserFontSet->mLocalRulesUsed &&
+ mUserFontSet->mRebuildLocalRules) {
+ nsCSSValue val;
+ aFontFace->GetDesc(eCSSFontDesc_Src, val);
+ nsCSSUnit unit = val.GetUnit();
+ if (unit == eCSSUnit_Array && HasLocalSrc(val.GetArrayValue())) {
+ // Remove the old record, but wait to see if we successfully create a
+ // new user font entry below.
+ remove = true;
+ removeIndex = i;
+ break;
+ }
+ }
+
+ gfxUserFontEntry* entry = rec.mFontFace->GetUserFontEntry();
+ MOZ_ASSERT(entry, "FontFace should have a gfxUserFontEntry by now");
+
+ mUserFontSet->AddUserFontEntry(fontfamily, entry);
+
+ MOZ_ASSERT(!HasRuleFontFace(rec.mFontFace),
+ "FontFace should not occur in mRuleFaces twice");
+
+ mRuleFaces.AppendElement(rec);
+ aOldRecords.RemoveElementAt(i);
+ // note the set has been modified if an old rule was skipped to find
+ // this one - something has been dropped, or ordering changed
+ if (i > 0) {
+ aFontSetModified = true;
+ }
+ return;
+ }
+ }
+
+ // this is a new rule:
+ RefPtr<gfxUserFontEntry> entry =
+ FindOrCreateUserFontEntryFromFontFace(fontfamily, aFontFace, aSheetType);
+
+ if (!entry) {
+ return;
+ }
+
+ if (remove) {
+ // Although we broke out of the aOldRecords loop above, since we found
+ // src local usage, and we're not using the old user font entry, we still
+ // are adding a record to mRuleFaces with the same FontFace object.
+ // Remove the old record so that we don't have the same FontFace listed
+ // in both mRuleFaces and oldRecords, which would cause us to call
+ // DisconnectFromRule on a FontFace that should still be rule backed.
+ aOldRecords.RemoveElementAt(removeIndex);
+ }
+
+ FontFaceRecord rec;
+ rec.mFontFace = aFontFace;
+ rec.mSheetType = aSheetType;
+ rec.mLoadEventShouldFire =
+ aFontFace->Status() == FontFaceLoadStatus::Unloaded ||
+ aFontFace->Status() == FontFaceLoadStatus::Loading;
+
+ aFontFace->SetUserFontEntry(entry);
+
+ MOZ_ASSERT(!HasRuleFontFace(aFontFace),
+ "FontFace should not occur in mRuleFaces twice");
+
+ mRuleFaces.AppendElement(rec);
+
+ // this was a new rule and font entry, so note that the set was modified
+ aFontSetModified = true;
+
+ // Add the entry to the end of the list. If an existing userfont entry was
+ // returned by FindOrCreateUserFontEntryFromFontFace that was already stored
+ // on the family, gfxUserFontFamily::AddFontEntry(), which AddUserFontEntry
+ // calls, will automatically remove the earlier occurrence of the same
+ // userfont entry.
+ mUserFontSet->AddUserFontEntry(fontfamily, entry);
+}
+
+/* static */ already_AddRefed<gfxUserFontEntry>
+FontFaceSet::FindOrCreateUserFontEntryFromFontFace(FontFace* aFontFace)
+{
+ nsAutoString fontfamily;
+ if (!aFontFace->GetFamilyName(fontfamily)) {
+ // If there is no family name, this rule cannot contribute a
+ // usable font, so there is no point in processing it further.
+ return nullptr;
+ }
+
+ return FindOrCreateUserFontEntryFromFontFace(fontfamily, aFontFace,
+ SheetType::Doc);
+}
+
+/* static */ already_AddRefed<gfxUserFontEntry>
+FontFaceSet::FindOrCreateUserFontEntryFromFontFace(const nsAString& aFamilyName,
+ FontFace* aFontFace,
+ SheetType aSheetType)
+{
+ FontFaceSet* set = aFontFace->GetPrimaryFontFaceSet();
+
+ nsCSSValue val;
+ nsCSSUnit unit;
+
+ uint32_t weight = NS_STYLE_FONT_WEIGHT_NORMAL;
+ int32_t stretch = NS_STYLE_FONT_STRETCH_NORMAL;
+ uint8_t italicStyle = NS_STYLE_FONT_STYLE_NORMAL;
+ uint32_t languageOverride = NO_FONT_LANGUAGE_OVERRIDE;
+ uint8_t fontDisplay = NS_FONT_DISPLAY_AUTO;
+
+ // set up weight
+ aFontFace->GetDesc(eCSSFontDesc_Weight, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Integer || unit == eCSSUnit_Enumerated) {
+ weight = val.GetIntValue();
+ if (weight == 0) {
+ weight = NS_STYLE_FONT_WEIGHT_NORMAL;
+ }
+ } else if (unit == eCSSUnit_Normal) {
+ weight = NS_STYLE_FONT_WEIGHT_NORMAL;
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null,
+ "@font-face weight has unexpected unit");
+ }
+
+ // set up stretch
+ aFontFace->GetDesc(eCSSFontDesc_Stretch, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Enumerated) {
+ stretch = val.GetIntValue();
+ } else if (unit == eCSSUnit_Normal) {
+ stretch = NS_STYLE_FONT_STRETCH_NORMAL;
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null,
+ "@font-face stretch has unexpected unit");
+ }
+
+ // set up font style
+ aFontFace->GetDesc(eCSSFontDesc_Style, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Enumerated) {
+ italicStyle = val.GetIntValue();
+ } else if (unit == eCSSUnit_Normal) {
+ italicStyle = NS_STYLE_FONT_STYLE_NORMAL;
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null,
+ "@font-face style has unexpected unit");
+ }
+
+ // set up font display
+ aFontFace->GetDesc(eCSSFontDesc_Display, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Enumerated) {
+ fontDisplay = val.GetIntValue();
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null,
+ "@font-face style has unexpected unit");
+ }
+
+ // set up font features
+ nsTArray<gfxFontFeature> featureSettings;
+ aFontFace->GetDesc(eCSSFontDesc_FontFeatureSettings, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Normal) {
+ // empty list of features
+ } else if (unit == eCSSUnit_PairList || unit == eCSSUnit_PairListDep) {
+ nsRuleNode::ComputeFontFeatures(val.GetPairListValue(), featureSettings);
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null,
+ "@font-face font-feature-settings has unexpected unit");
+ }
+
+ // set up font language override
+ aFontFace->GetDesc(eCSSFontDesc_FontLanguageOverride, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Normal) {
+ // empty feature string
+ } else if (unit == eCSSUnit_String) {
+ nsString stringValue;
+ val.GetStringValue(stringValue);
+ languageOverride = gfxFontStyle::ParseFontLanguageOverride(stringValue);
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null,
+ "@font-face font-language-override has unexpected unit");
+ }
+
+ // set up unicode-range
+ nsAutoPtr<gfxCharacterMap> unicodeRanges;
+ aFontFace->GetDesc(eCSSFontDesc_UnicodeRange, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Array) {
+ unicodeRanges = new gfxCharacterMap();
+ const nsCSSValue::Array& sources = *val.GetArrayValue();
+ MOZ_ASSERT(sources.Count() % 2 == 0,
+ "odd number of entries in a unicode-range: array");
+
+ for (uint32_t i = 0; i < sources.Count(); i += 2) {
+ uint32_t min = sources[i].GetIntValue();
+ uint32_t max = sources[i+1].GetIntValue();
+ unicodeRanges->SetRange(min, max);
+ }
+ }
+
+ // 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->CreateBufferSource();
+ } else {
+ aFontFace->GetDesc(eCSSFontDesc_Src, val);
+ unit = val.GetUnit();
+ if (unit == eCSSUnit_Array) {
+ nsCSSValue::Array* srcArr = val.GetArrayValue();
+ size_t numSrc = srcArr->Count();
+
+ for (size_t i = 0; i < numSrc; i++) {
+ val = srcArr->Item(i);
+ unit = val.GetUnit();
+ gfxFontFaceSrc* face = srcArray.AppendElements(1);
+ if (!face)
+ return nullptr;
+
+ switch (unit) {
+
+ case eCSSUnit_Local_Font:
+ val.GetStringValue(face->mLocalName);
+ face->mSourceType = gfxFontFaceSrc::eSourceType_Local;
+ face->mURI = nullptr;
+ face->mFormatFlags = 0;
+ break;
+ case eCSSUnit_URL:
+ face->mSourceType = gfxFontFaceSrc::eSourceType_URL;
+ face->mURI = val.GetURLValue();
+ face->mReferrer = val.GetURLStructValue()->mReferrer;
+ face->mReferrerPolicy = set->mDocument->GetReferrerPolicy();
+ face->mOriginPrincipal = val.GetURLStructValue()->mOriginPrincipal;
+ NS_ASSERTION(face->mOriginPrincipal, "null origin principal in @font-face rule");
+
+ // 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
+ face->mUseOriginPrincipal = (aSheetType == SheetType::User ||
+ aSheetType == SheetType::Agent);
+
+ face->mLocalName.Truncate();
+ face->mFormatFlags = 0;
+ while (i + 1 < numSrc && (val = srcArr->Item(i+1),
+ val.GetUnit() == eCSSUnit_Font_Format)) {
+ nsDependentString valueString(val.GetStringBufferValue());
+ if (valueString.LowerCaseEqualsASCII("woff")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_WOFF;
+ } else if (Preferences::GetBool(GFX_PREF_WOFF2_ENABLED) &&
+ valueString.LowerCaseEqualsASCII("woff2")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_WOFF2;
+ } else if (valueString.LowerCaseEqualsASCII("opentype")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_OPENTYPE;
+ } else if (valueString.LowerCaseEqualsASCII("truetype")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_TRUETYPE;
+ } else if (valueString.LowerCaseEqualsASCII("truetype-aat")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_TRUETYPE_AAT;
+ } else if (valueString.LowerCaseEqualsASCII("embedded-opentype")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_EOT;
+ } else if (valueString.LowerCaseEqualsASCII("svg")) {
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_SVG;
+ } else {
+ // unknown format specified, mark to distinguish from the
+ // case where no format hints are specified
+ face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_UNKNOWN;
+ }
+ i++;
+ }
+ if (!face->mURI) {
+ // if URI not valid, omit from src array
+ srcArray.RemoveElementAt(srcArray.Length() - 1);
+ NS_WARNING("null url in @font-face rule");
+ continue;
+ }
+ break;
+ default:
+ NS_ASSERTION(unit == eCSSUnit_Local_Font || unit == eCSSUnit_URL,
+ "strange unit type in font-face src array");
+ break;
+ }
+ }
+ } else {
+ NS_ASSERTION(unit == eCSSUnit_Null, "@font-face src has unexpected unit");
+ }
+ }
+
+ if (srcArray.IsEmpty()) {
+ return nullptr;
+ }
+
+ RefPtr<gfxUserFontEntry> entry =
+ set->mUserFontSet->FindOrCreateUserFontEntry(aFamilyName, srcArray, weight,
+ stretch, italicStyle,
+ featureSettings,
+ languageOverride,
+ unicodeRanges, fontDisplay);
+ return entry.forget();
+}
+
+nsCSSFontFaceRule*
+FontFaceSet::FindRuleForEntry(gfxFontEntry* aFontEntry)
+{
+ NS_ASSERTION(!aFontEntry->mIsUserFontContainer, "only platform font entries");
+ for (uint32_t i = 0; i < mRuleFaces.Length(); ++i) {
+ FontFace* f = mRuleFaces[i].mFontFace;
+ gfxUserFontEntry* entry = f->GetUserFontEntry();
+ if (entry && entry->GetPlatformFontEntry() == aFontEntry) {
+ return f->GetRule();
+ }
+ }
+ return nullptr;
+}
+
+nsCSSFontFaceRule*
+FontFaceSet::FindRuleForUserFontEntry(gfxUserFontEntry* aUserFontEntry)
+{
+ for (uint32_t i = 0; i < mRuleFaces.Length(); ++i) {
+ FontFace* f = mRuleFaces[i].mFontFace;
+ if (f->GetUserFontEntry() == aUserFontEntry) {
+ return f->GetRule();
+ }
+ }
+ return nullptr;
+}
+
+nsresult
+FontFaceSet::LogMessage(gfxUserFontEntry* aUserFontEntry,
+ const char* aMessage,
+ uint32_t aFlags,
+ nsresult aStatus)
+{
+ nsCOMPtr<nsIConsoleService>
+ console(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+ if (!console) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ nsAutoCString familyName;
+ nsAutoCString fontURI;
+ aUserFontEntry->GetFamilyNameAndURIForLogging(familyName, fontURI);
+
+ char weightKeywordBuf[8]; // plenty to sprintf() a uint16_t
+ const char* weightKeyword;
+ const nsAFlatCString& weightKeywordString =
+ nsCSSProps::ValueToKeyword(aUserFontEntry->Weight(),
+ nsCSSProps::kFontWeightKTable);
+ if (weightKeywordString.Length() > 0) {
+ weightKeyword = weightKeywordString.get();
+ } else {
+ SprintfLiteral(weightKeywordBuf, "%u", aUserFontEntry->Weight());
+ weightKeyword = weightKeywordBuf;
+ }
+
+ nsPrintfCString message
+ ("downloadable font: %s "
+ "(font-family: \"%s\" style:%s weight:%s stretch:%s src index:%d)",
+ aMessage,
+ familyName.get(),
+ aUserFontEntry->IsItalic() ? "italic" : "normal",
+ weightKeyword,
+ nsCSSProps::ValueToKeyword(aUserFontEntry->Stretch(),
+ nsCSSProps::kFontStretchKTable).get(),
+ aUserFontEntry->GetSrcIndex());
+
+ 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);
+
+ if (LOG_ENABLED()) {
+ LOG(("userfonts (%p) %s", mUserFontSet.get(), message.get()));
+ }
+
+ // try to give the user an indication of where the rule came from
+ nsCSSFontFaceRule* rule = FindRuleForUserFontEntry(aUserFontEntry);
+ nsString href;
+ nsString text;
+ nsresult rv;
+ uint32_t line = 0;
+ uint32_t column = 0;
+ if (rule) {
+ rv = rule->GetCssText(text);
+ NS_ENSURE_SUCCESS(rv, rv);
+ CSSStyleSheet* 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");
+ }
+ line = rule->GetLineNumber();
+ column = rule->GetColumnNumber();
+ }
+
+ nsCOMPtr<nsIScriptError> scriptError =
+ do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint64_t innerWindowID = mDocument->InnerWindowID();
+ rv = scriptError->InitWithWindowID(NS_ConvertUTF8toUTF16(message),
+ href, // file
+ text, // src line
+ line,
+ column,
+ aFlags, // flags
+ "CSS Loader", // category (make separate?)
+ innerWindowID);
+ if (NS_SUCCEEDED(rv)) {
+ console->LogMessage(scriptError);
+ }
+
+ return NS_OK;
+}
+
+nsresult
+FontFaceSet::CheckFontLoad(const gfxFontFaceSrc* aFontFaceSrc,
+ nsIPrincipal** aPrincipal,
+ bool* aBypassCache)
+{
+ NS_ASSERTION(aFontFaceSrc &&
+ aFontFaceSrc->mSourceType == gfxFontFaceSrc::eSourceType_URL,
+ "bad font face url passed to fontloader");
+
+ // check same-site origin
+
+ NS_ASSERTION(aFontFaceSrc->mURI, "null font uri");
+ if (!aFontFaceSrc->mURI)
+ return NS_ERROR_FAILURE;
+
+ // use document principal, original principal if flag set
+ // this enables user stylesheets to load font files via
+ // @font-face rules
+ *aPrincipal = mDocument->NodePrincipal();
+
+ NS_ASSERTION(aFontFaceSrc->mOriginPrincipal,
+ "null origin principal in @font-face rule");
+ if (aFontFaceSrc->mUseOriginPrincipal) {
+ *aPrincipal = aFontFaceSrc->mOriginPrincipal;
+ }
+
+ *aBypassCache = false;
+
+ nsCOMPtr<nsIDocShell> docShell = mDocument->GetDocShell();
+ if (docShell) {
+ uint32_t loadType;
+ if (NS_SUCCEEDED(docShell->GetLoadType(&loadType))) {
+ if ((loadType >> 16) & nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE) {
+ *aBypassCache = true;
+ }
+ }
+ uint32_t flags;
+ if (NS_SUCCEEDED(docShell->GetDefaultLoadFlags(&flags))) {
+ if (flags & nsIRequest::LOAD_BYPASS_CACHE) {
+ *aBypassCache = true;
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+
+// @arg aPrincipal: generally this is mDocument->NodePrincipal() but
+// might also be the original principal which enables user stylesheets
+// to load font files via @font-face rules.
+bool
+FontFaceSet::IsFontLoadAllowed(nsIURI* aFontLocation, nsIPrincipal* aPrincipal)
+{
+ int16_t shouldLoad = nsIContentPolicy::ACCEPT;
+ nsresult rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_FONT,
+ aFontLocation,
+ aPrincipal,
+ mDocument,
+ EmptyCString(), // mime type
+ nullptr, // aExtra
+ &shouldLoad,
+ nsContentUtils::GetContentPolicy(),
+ nsContentUtils::GetSecurityManager());
+
+ return NS_SUCCEEDED(rv) && NS_CP_ACCEPTED(shouldLoad);
+}
+
+nsresult
+FontFaceSet::SyncLoadFontData(gfxUserFontEntry* aFontToLoad,
+ const gfxFontFaceSrc* aFontFaceSrc,
+ uint8_t*& aBuffer,
+ uint32_t& aBufferLength)
+{
+ nsresult rv;
+
+ nsCOMPtr<nsIChannel> channel;
+ // Note we are calling NS_NewChannelWithTriggeringPrincipal() with both a
+ // node and a principal. This is because the document where the font is
+ // being loaded might have a different origin from the principal of the
+ // stylesheet that initiated the font load.
+ // Further, we only get here for data: loads, so it doesn't really matter
+ // whether we use SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS or not, to be more
+ // restrictive we use SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS.
+ rv = NS_NewChannelWithTriggeringPrincipal(getter_AddRefs(channel),
+ aFontFaceSrc->mURI,
+ mDocument,
+ aFontToLoad->GetPrincipal(),
+ nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS,
+ nsIContentPolicy::TYPE_FONT);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // blocking stream is OK for data URIs
+ nsCOMPtr<nsIInputStream> stream;
+ rv = channel->Open2(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*> (moz_xmalloc(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;
+}
+
+bool
+FontFaceSet::GetPrivateBrowsing()
+{
+ nsCOMPtr<nsILoadContext> loadContext = mDocument->GetLoadContext();
+ return loadContext && loadContext->UsePrivateBrowsing();
+}
+
+void
+FontFaceSet::OnFontFaceStatusChanged(FontFace* aFontFace)
+{
+ 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;
+ nsCOMPtr<nsIRunnable> checkTask =
+ NewRunnableMethod(this, &FontFaceSet::CheckLoadingFinishedAfterDelay);
+ NS_DispatchToMainThread(checkTask);
+ }
+ }
+}
+
+void
+FontFaceSet::DidRefresh()
+{
+ CheckLoadingFinished();
+}
+
+void
+FontFaceSet::CheckLoadingFinishedAfterDelay()
+{
+ mDelayedLoadCheck = false;
+ CheckLoadingFinished();
+}
+
+void
+FontFaceSet::CheckLoadingStarted()
+{
+ 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;
+ (new AsyncEventDispatcher(this, NS_LITERAL_STRING("loading"),
+ false))->PostDOMEvent();
+
+ if (PrefEnabled()) {
+ if (mReady) {
+ if (GetParentObject()) {
+ ErrorResult rv;
+ mReady = Promise::Create(GetParentObject(), rv);
+ }
+ }
+ if (!mReady) {
+ mResolveLazilyCreatedReadyPromise = false;
+ }
+ }
+}
+
+void
+FontFaceSet::UpdateHasLoadingFontFaces()
+{
+ mHasLoadingFontFacesIsDirty = false;
+ mHasLoadingFontFaces = false;
+ for (size_t i = 0; i < mRuleFaces.Length(); i++) {
+ FontFace* f = mRuleFaces[i].mFontFace;
+ if (f->Status() == FontFaceLoadStatus::Loading) {
+ mHasLoadingFontFaces = true;
+ return;
+ }
+ }
+ for (size_t i = 0; i < mNonRuleFaces.Length(); i++) {
+ if (mNonRuleFaces[i].mFontFace->Status() == FontFaceLoadStatus::Loading) {
+ mHasLoadingFontFaces = true;
+ return;
+ }
+ }
+}
+
+bool
+FontFaceSet::HasLoadingFontFaces()
+{
+ if (mHasLoadingFontFacesIsDirty) {
+ UpdateHasLoadingFontFaces();
+ }
+ return mHasLoadingFontFaces;
+}
+
+bool
+FontFaceSet::MightHavePendingFontLoads()
+{
+ // Check for FontFace objects in the FontFaceSet that are still loading.
+ if (HasLoadingFontFaces()) {
+ return true;
+ }
+
+ // Check for pending restyles or reflows, as they might cause fonts to
+ // load as new styles apply and text runs are rebuilt.
+ nsPresContext* presContext = GetPresContext();
+ if (presContext && presContext->HasPendingRestyleOrReflow()) {
+ return true;
+ }
+
+ if (mDocument) {
+ // We defer resolving mReady until the document as fully loaded.
+ if (!mDocument->DidFireDOMContentLoaded()) {
+ return true;
+ }
+
+ // And we also wait for any CSS style sheets to finish loading, as their
+ // styles might cause new fonts to load.
+ if (mDocument->CSSLoader()->HasPendingLoads()) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void
+FontFaceSet::CheckLoadingFinished()
+{
+ if (mDelayedLoadCheck) {
+ // Wait until the runnable posted in OnFontFaceStatusChanged calls us.
+ return;
+ }
+
+ if (mStatus == FontFaceSetLoadStatus::Loaded) {
+ // We've already resolved mReady and dispatched the loadingdone/loadingerror
+ // events.
+ return;
+ }
+
+ if (MightHavePendingFontLoads()) {
+ // We're not finished loading yet.
+ return;
+ }
+
+ mStatus = FontFaceSetLoadStatus::Loaded;
+ if (mReady) {
+ mReady->MaybeResolve(this);
+ } else {
+ mResolveLazilyCreatedReadyPromise = true;
+ }
+
+ // Now dispatch the loadingdone/loadingerror events.
+ nsTArray<FontFace*> loaded;
+ nsTArray<FontFace*> failed;
+
+ for (size_t i = 0; i < mRuleFaces.Length(); i++) {
+ if (!mRuleFaces[i].mLoadEventShouldFire) {
+ continue;
+ }
+ FontFace* f = mRuleFaces[i].mFontFace;
+ if (f->Status() == FontFaceLoadStatus::Loaded) {
+ loaded.AppendElement(f);
+ mRuleFaces[i].mLoadEventShouldFire = false;
+ } else if (f->Status() == FontFaceLoadStatus::Error) {
+ failed.AppendElement(f);
+ mRuleFaces[i].mLoadEventShouldFire = false;
+ }
+ }
+
+ for (size_t i = 0; i < mNonRuleFaces.Length(); i++) {
+ if (!mNonRuleFaces[i].mLoadEventShouldFire) {
+ continue;
+ }
+ FontFace* f = mNonRuleFaces[i].mFontFace;
+ if (f->Status() == FontFaceLoadStatus::Loaded) {
+ loaded.AppendElement(f);
+ mNonRuleFaces[i].mLoadEventShouldFire = false;
+ } else if (f->Status() == FontFaceLoadStatus::Error) {
+ failed.AppendElement(f);
+ mNonRuleFaces[i].mLoadEventShouldFire = false;
+ }
+ }
+
+ DispatchLoadingFinishedEvent(NS_LITERAL_STRING("loadingdone"), loaded);
+
+ if (!failed.IsEmpty()) {
+ DispatchLoadingFinishedEvent(NS_LITERAL_STRING("loadingerror"), failed);
+ }
+}
+
+void
+FontFaceSet::DispatchLoadingFinishedEvent(
+ const nsAString& aType,
+ const nsTArray<FontFace*>& aFontFaces)
+{
+ FontFaceSetLoadEventInit init;
+ init.mBubbles = false;
+ init.mCancelable = false;
+ OwningNonNull<FontFace>* elements =
+ init.mFontfaces.AppendElements(aFontFaces.Length(), fallible);
+ MOZ_ASSERT(elements);
+ for (size_t i = 0; i < aFontFaces.Length(); i++) {
+ elements[i] = aFontFaces[i];
+ }
+ RefPtr<FontFaceSetLoadEvent> event =
+ FontFaceSetLoadEvent::Constructor(this, aType, init);
+ (new AsyncEventDispatcher(this, event))->PostDOMEvent();
+}
+
+// nsIDOMEventListener
+
+NS_IMETHODIMP
+FontFaceSet::HandleEvent(nsIDOMEvent* aEvent)
+{
+ nsString type;
+ aEvent->GetType(type);
+
+ if (!type.EqualsLiteral("DOMContentLoaded")) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RemoveDOMContentLoadedListener();
+ CheckLoadingFinished();
+
+ return NS_OK;
+}
+
+/* static */ bool
+FontFaceSet::PrefEnabled()
+{
+ static bool initialized = false;
+ static bool enabled;
+ if (!initialized) {
+ initialized = true;
+ Preferences::AddBoolVarCache(&enabled, FONT_LOADING_API_ENABLED_PREF);
+ }
+ return enabled;
+}
+
+// nsICSSLoaderObserver
+
+NS_IMETHODIMP
+FontFaceSet::StyleSheetLoaded(StyleSheet* aSheet,
+ bool aWasAlternate,
+ nsresult aStatus)
+{
+ CheckLoadingFinished();
+ return NS_OK;
+}
+
+void
+FontFaceSet::FlushUserFontSet()
+{
+ if (mDocument) {
+ mDocument->FlushUserFontSet();
+ }
+}
+
+void
+FontFaceSet::RebuildUserFontSet()
+{
+ if (mDocument) {
+ mDocument->RebuildUserFontSet();
+ }
+}
+
+nsPresContext*
+FontFaceSet::GetPresContext()
+{
+ if (!mDocument) {
+ return nullptr;
+ }
+
+ nsIPresShell* shell = mDocument->GetShell();
+ return shell ? shell->GetPresContext() : nullptr;
+}
+
+// -- FontFaceSet::UserFontSet ------------------------------------------------
+
+/* virtual */ nsresult
+FontFaceSet::UserFontSet::CheckFontLoad(const gfxFontFaceSrc* aFontFaceSrc,
+ nsIPrincipal** aPrincipal,
+ bool* aBypassCache)
+{
+ if (!mFontFaceSet) {
+ return NS_ERROR_FAILURE;
+ }
+ return mFontFaceSet->CheckFontLoad(aFontFaceSrc, aPrincipal, aBypassCache);
+}
+
+/* virtual */ bool
+FontFaceSet::UserFontSet::IsFontLoadAllowed(nsIURI* aFontLocation,
+ nsIPrincipal* aPrincipal)
+{
+ return mFontFaceSet &&
+ mFontFaceSet->IsFontLoadAllowed(aFontLocation, aPrincipal);
+}
+
+/* virtual */ nsresult
+FontFaceSet::UserFontSet::StartLoad(gfxUserFontEntry* aUserFontEntry,
+ const gfxFontFaceSrc* aFontFaceSrc)
+{
+ if (!mFontFaceSet) {
+ return NS_ERROR_FAILURE;
+ }
+ return mFontFaceSet->StartLoad(aUserFontEntry, aFontFaceSrc);
+}
+
+void
+FontFaceSet::UserFontSet::RecordFontLoadDone(uint32_t aFontSize,
+ TimeStamp aDoneTime)
+{
+ mDownloadCount++;
+ mDownloadSize += aFontSize;
+ Telemetry::Accumulate(Telemetry::WEBFONT_SIZE, aFontSize / 1024);
+
+ if (!mFontFaceSet) {
+ return;
+ }
+
+ TimeStamp navStart = mFontFaceSet->GetNavigationStartTimeStamp();
+ TimeStamp zero;
+ if (navStart != zero) {
+ Telemetry::AccumulateTimeDelta(Telemetry::WEBFONT_DOWNLOAD_TIME_AFTER_START,
+ navStart, aDoneTime);
+ }
+}
+
+/* virtual */ nsresult
+FontFaceSet::UserFontSet::LogMessage(gfxUserFontEntry* aUserFontEntry,
+ const char* aMessage,
+ uint32_t aFlags,
+ nsresult aStatus)
+{
+ if (!mFontFaceSet) {
+ return NS_ERROR_FAILURE;
+ }
+ return mFontFaceSet->LogMessage(aUserFontEntry, aMessage, aFlags, aStatus);
+}
+
+/* virtual */ nsresult
+FontFaceSet::UserFontSet::SyncLoadFontData(gfxUserFontEntry* aFontToLoad,
+ const gfxFontFaceSrc* aFontFaceSrc,
+ uint8_t*& aBuffer,
+ uint32_t& aBufferLength)
+{
+ if (!mFontFaceSet) {
+ return NS_ERROR_FAILURE;
+ }
+ return mFontFaceSet->SyncLoadFontData(aFontToLoad, aFontFaceSrc,
+ aBuffer, aBufferLength);
+}
+
+/* virtual */ bool
+FontFaceSet::UserFontSet::GetPrivateBrowsing()
+{
+ return mFontFaceSet && mFontFaceSet->GetPrivateBrowsing();
+}
+
+/* virtual */ void
+FontFaceSet::UserFontSet::DoRebuildUserFontSet()
+{
+ if (!mFontFaceSet) {
+ return;
+ }
+ mFontFaceSet->RebuildUserFontSet();
+}
+
+/* virtual */ already_AddRefed<gfxUserFontEntry>
+FontFaceSet::UserFontSet::CreateUserFontEntry(
+ const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
+ uint32_t aWeight,
+ int32_t aStretch,
+ uint8_t aStyle,
+ const nsTArray<gfxFontFeature>& aFeatureSettings,
+ uint32_t aLanguageOverride,
+ gfxSparseBitSet* aUnicodeRanges,
+ uint8_t aFontDisplay)
+{
+ RefPtr<gfxUserFontEntry> entry =
+ new FontFace::Entry(this, aFontFaceSrcList, aWeight, aStretch, aStyle,
+ aFeatureSettings, aLanguageOverride, aUnicodeRanges,
+ aFontDisplay);
+ return entry.forget();
+}
+
+#undef LOG_ENABLED
+#undef LOG
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-10 10:19:02 +0000