1 files changed, 344 insertions, 0 deletions
diff --git a/gfx/thebes/gfxFontFamilyList.h b/gfx/thebes/gfxFontFamilyList.h
new file mode 100644
index 0000000000..5ed650a646
--- /dev/null
+++ b/gfx/thebes/gfxFontFamilyList.h
@@ -0,0 +1,344 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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/. */
+
+#ifndef GFX_FONT_FAMILY_LIST_H
+#define GFX_FONT_FAMILY_LIST_H
+
+#include "nsAtom.h"
+#include "nsDebug.h"
+#include "nsISupportsImpl.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsUnicharUtils.h"
+#include "nsTArray.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/ServoStyleConsts.h"
+#include "mozilla/StaticPtr.h"
+
+namespace mozilla {
+
+/**
+ * font family name, an Atom for the name if not a generic and
+ * a font type indicated named family or which generic family
+ */
+
+struct FontFamilyName final {
+  using Syntax = StyleFontFamilyNameSyntax;
+
+  FontFamilyName() = delete;
+
+  // named font family - e.g. Helvetica
+  explicit FontFamilyName(nsAtom* aFamilyName, Syntax aSyntax)
+      : mName(aFamilyName), mSyntax(aSyntax) {}
+
+  explicit FontFamilyName(const nsACString& aFamilyName, Syntax aSyntax)
+      : mName(NS_Atomize(aFamilyName)), mSyntax(aSyntax) {}
+
+  // generic font family - e.g. sans-serif
+  explicit FontFamilyName(StyleGenericFontFamily aGeneric)
+      : mGeneric(aGeneric) {
+    MOZ_ASSERT(mGeneric != StyleGenericFontFamily::None);
+  }
+
+  FontFamilyName(const FontFamilyName&) = default;
+
+  bool IsNamed() const { return !!mName; }
+
+  bool IsGeneric() const { return !IsNamed(); }
+
+  bool IsQuoted() const { return mSyntax == StyleFontFamilyNameSyntax::Quoted; }
+
+  void AppendToString(nsACString& aFamilyList, bool aQuotes = true) const {
+    if (IsNamed()) {
+      if (mSyntax == Syntax::Identifiers) {
+        return aFamilyList.Append(nsAtomCString(mName));
+      }
+      if (aQuotes) {
+        aFamilyList.Append('"');
+      }
+      aFamilyList.Append(nsAtomCString(mName));
+      if (aQuotes) {
+        aFamilyList.Append('"');
+      }
+      return;
+    }
+    switch (mGeneric) {
+      case StyleGenericFontFamily::None:
+      case StyleGenericFontFamily::MozEmoji:
+        MOZ_FALLTHROUGH_ASSERT("Should never appear in a font-family name!");
+      case StyleGenericFontFamily::Serif:
+        return aFamilyList.AppendLiteral("serif");
+      case StyleGenericFontFamily::SansSerif:
+        return aFamilyList.AppendLiteral("sans-serif");
+      case StyleGenericFontFamily::Monospace:
+        return aFamilyList.AppendLiteral("monospace");
+      case StyleGenericFontFamily::Cursive:
+        return aFamilyList.AppendLiteral("cursive");
+      case StyleGenericFontFamily::Fantasy:
+        return aFamilyList.AppendLiteral("fantasy");
+    }
+    MOZ_ASSERT_UNREACHABLE("Unknown generic font-family!");
+    return aFamilyList.AppendLiteral("serif");
+  }
+
+  // helper method that converts generic names to the right enum value
+  static FontFamilyName Convert(const nsACString& aFamilyOrGenericName) {
+    // should only be passed a single font - not entirely correct, a family
+    // *could* have a comma in it but in practice never does so
+    // for debug purposes this is fine
+    NS_ASSERTION(aFamilyOrGenericName.FindChar(',') == -1,
+                 "Convert method should only be passed a single family name");
+
+    auto genericType = StyleGenericFontFamily::None;
+    if (aFamilyOrGenericName.LowerCaseEqualsLiteral("serif")) {
+      genericType = StyleGenericFontFamily::Serif;
+    } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("sans-serif")) {
+      genericType = StyleGenericFontFamily::SansSerif;
+    } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("monospace") ||
+               aFamilyOrGenericName.LowerCaseEqualsLiteral("-moz-fixed")) {
+      genericType = StyleGenericFontFamily::Monospace;
+    } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("cursive")) {
+      genericType = StyleGenericFontFamily::Cursive;
+    } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("fantasy")) {
+      genericType = StyleGenericFontFamily::Fantasy;
+    } else {
+      return FontFamilyName(aFamilyOrGenericName, Syntax::Identifiers);
+    }
+
+    return FontFamilyName(genericType);
+  }
+
+  bool IsNamedFamily(const nsAString& aFamilyName) const {
+    if (!IsNamed()) {
+      return false;
+    }
+    nsDependentAtomString name{mName};
+    return name.Equals(aFamilyName, nsCaseInsensitiveStringComparator);
+  }
+
+  RefPtr<nsAtom> mName;  // null if mGeneric != Default
+  StyleFontFamilyNameSyntax mSyntax = StyleFontFamilyNameSyntax::Quoted;
+  StyleGenericFontFamily mGeneric = StyleGenericFontFamily::None;
+};
+
+inline bool operator==(const FontFamilyName& a, const FontFamilyName& b) {
+  return a.mName == b.mName && a.mSyntax == b.mSyntax &&
+         a.mGeneric == b.mGeneric;
+}
+
+/**
+ * A refcounted array of FontFamilyNames.  We use this to store the specified
+ * and computed value of the font-family property.
+ *
+ * TODO(heycam): It might better to define this type (and FontFamilyList and
+ * FontFamilyName) in Rust.
+ */
+class SharedFontList {
+  using Syntax = StyleFontFamilyNameSyntax;
+
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedFontList);
+
+  SharedFontList() = default;
+
+  explicit SharedFontList(StyleGenericFontFamily aGenericType)
+      : mNames{FontFamilyName(aGenericType)} {}
+
+  SharedFontList(nsAtom* aFamilyName, Syntax aSyntax)
+      : mNames{FontFamilyName(aFamilyName, aSyntax)} {}
+
+  SharedFontList(const nsACString& aFamilyName, Syntax aSyntax)
+      : mNames{FontFamilyName(aFamilyName, aSyntax)} {}
+
+  explicit SharedFontList(nsTArray<FontFamilyName>&& aNames)
+      : mNames(std::move(aNames)) {}
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+    size_t n = 0;
+    n += aMallocSizeOf(this);
+    n += mNames.ShallowSizeOfExcludingThis(aMallocSizeOf);
+    return n;
+  }
+
+  size_t SizeOfIncludingThisIfUnshared(MallocSizeOf aMallocSizeOf) const {
+    size_t n = 0;
+    if (mRefCnt.get() == 1) {
+      n += SizeOfIncludingThis(aMallocSizeOf);
+    }
+    return n;
+  }
+
+  const nsTArray<FontFamilyName> mNames{};
+
+  static void Initialize();
+  static void Shutdown();
+  static StaticRefPtr<SharedFontList> sEmpty;
+  static StaticRefPtr<SharedFontList>
+      sSingleGenerics[size_t(StyleGenericFontFamily::MozEmoji)];
+
+ private:
+  ~SharedFontList() = default;
+};
+
+/**
+ * font family list, array of font families and a default font type.
+ * font family names are either named strings or generics. the default
+ * font type is used to preserve the variable font fallback behavior
+ */
+class FontFamilyList {
+  using Syntax = StyleFontFamilyNameSyntax;
+
+ public:
+  FontFamilyList() = default;
+
+  explicit FontFamilyList(StyleGenericFontFamily aGenericType)
+      : mFontlist(MakeNotNull<SharedFontList*>(aGenericType)) {}
+
+  FontFamilyList(nsAtom* aFamilyName, Syntax aSyntax)
+      : mFontlist(MakeNotNull<SharedFontList*>(aFamilyName, aSyntax)) {}
+
+  FontFamilyList(const nsACString& aFamilyName, Syntax aSyntax)
+      : mFontlist(MakeNotNull<SharedFontList*>(aFamilyName, aSyntax)) {}
+
+  explicit FontFamilyList(nsTArray<FontFamilyName>&& aNames)
+      : mFontlist(MakeNotNull<SharedFontList*>(std::move(aNames))) {}
+
+  FontFamilyList(const FontFamilyList& aOther) = default;
+
+  explicit FontFamilyList(NotNull<SharedFontList*> aFontList)
+      : mFontlist(aFontList) {}
+
+  void SetFontlist(nsTArray<FontFamilyName>&& aNames) {
+    mFontlist = MakeNotNull<SharedFontList*>(std::move(aNames));
+  }
+
+  void SetFontlist(NotNull<SharedFontList*> aFontlist) {
+    mFontlist = aFontlist;
+  }
+
+  uint32_t Length() const { return mFontlist->mNames.Length(); }
+
+  bool IsEmpty() const { return mFontlist->mNames.IsEmpty(); }
+
+  NotNull<SharedFontList*> GetFontlist() const { return mFontlist; }
+
+  bool Equals(const FontFamilyList& aFontlist) const {
+    return (mFontlist == aFontlist.mFontlist ||
+            mFontlist->mNames == aFontlist.mFontlist->mNames) &&
+           mDefaultFontType == aFontlist.mDefaultFontType;
+  }
+
+  bool HasDefaultGeneric() const {
+    if (mDefaultFontType == StyleGenericFontFamily::None) {
+      return false;
+    }
+    for (const FontFamilyName& name : mFontlist->mNames) {
+      if (name.mGeneric == mDefaultFontType) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Find the first generic (but ignoring cursive and fantasy, as they are
+  // rarely configured in any useful way) in the list.
+  // If found, move it to the start and return true; else return false.
+  bool PrioritizeFirstGeneric() {
+    uint32_t len = mFontlist->mNames.Length();
+    for (uint32_t i = 0; i < len; i++) {
+      const FontFamilyName name = mFontlist->mNames[i];
+      if (name.IsGeneric()) {
+        if (name.mGeneric == StyleGenericFontFamily::Cursive ||
+            name.mGeneric == StyleGenericFontFamily::Fantasy) {
+          continue;
+        }
+        if (i > 0) {
+          nsTArray<FontFamilyName> names;
+          names.AppendElements(mFontlist->mNames);
+          names.RemoveElementAt(i);
+          names.InsertElementAt(0, name);
+          SetFontlist(std::move(names));
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void PrependGeneric(StyleGenericFontFamily aGeneric) {
+    nsTArray<FontFamilyName> names;
+    names.AppendElements(mFontlist->mNames);
+    names.InsertElementAt(0, FontFamilyName(aGeneric));
+    SetFontlist(std::move(names));
+  }
+
+  void ToString(nsACString& aFamilyList, bool aQuotes = true,
+                bool aIncludeDefault = false) const {
+    aFamilyList =
+        StringJoin(","_ns, mFontlist->mNames,
+                   [aQuotes](nsACString& dst, const FontFamilyName& name) {
+                     name.AppendToString(dst, aQuotes);
+                   });
+    if (aIncludeDefault && mDefaultFontType != StyleGenericFontFamily::None) {
+      if (!aFamilyList.IsEmpty()) {
+        aFamilyList.Append(',');
+      }
+      if (mDefaultFontType == StyleGenericFontFamily::Serif) {
+        aFamilyList.AppendLiteral("serif");
+      } else {
+        aFamilyList.AppendLiteral("sans-serif");
+      }
+    }
+  }
+
+  // searches for a specific non-generic name, case-insensitive comparison
+  bool Contains(const nsAString& aFamilyName) const {
+    for (const FontFamilyName& name : mFontlist->mNames) {
+      if (name.IsNamedFamily(aFamilyName)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  StyleGenericFontFamily GetDefaultFontType() const { return mDefaultFontType; }
+  void SetDefaultFontType(StyleGenericFontFamily aType) {
+    NS_ASSERTION(aType == StyleGenericFontFamily::None ||
+                     aType == StyleGenericFontFamily::Serif ||
+                     aType == StyleGenericFontFamily::SansSerif,
+                 "default font type must be either serif or sans-serif");
+    mDefaultFontType = aType;
+  }
+
+  // memory reporting
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+    size_t n = 0;
+    n += mFontlist->SizeOfIncludingThisIfUnshared(aMallocSizeOf);
+    return n;
+  }
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+ protected:
+  NotNull<RefPtr<SharedFontList>> mFontlist{
+      WrapNotNull(SharedFontList::sEmpty.get())};
+  StyleGenericFontFamily mDefaultFontType =
+      StyleGenericFontFamily::None;  // or serif, or sans-serif
+};
+
+inline bool operator==(const FontFamilyList& a, const FontFamilyList& b) {
+  return a.Equals(b);
+}
+
+inline bool operator!=(const FontFamilyList& a, const FontFamilyList& b) {
+  return !a.Equals(b);
+}
+
+}  // namespace mozilla
+
+#endif /* GFX_FONT_FAMILY_LIST_H */