Add m-esr52 at 52.6.0

1 files changed, 364 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFontFamilyList.h b/gfx/thebes/gfxFontFamilyList.h
new file mode 100644
index 000000000..e240102e0
--- /dev/null
+++ b/gfx/thebes/gfxFontFamilyList.h
@@ -0,0 +1,364 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * 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 "nsDebug.h"
+#include "nsISupportsImpl.h"
+#include "nsString.h"
+#include "nsUnicharUtils.h"
+#include "nsTArray.h"
+#include "mozilla/MemoryReporting.h"
+
+namespace mozilla {
+
+/**
+ * type of font family name, either a name (e.g. Helvetica) or a
+ * generic (e.g. serif, sans-serif), with the ability to distinguish
+ * between unquoted and quoted names for serializaiton
+ */ 
+
+enum FontFamilyType : uint32_t {
+  eFamily_none = 0,  // used when finding generics
+
+  // explicitly named font family (e.g. Helvetica)
+  eFamily_named,
+  eFamily_named_quoted,
+
+  // generics
+  eFamily_serif,         // pref font code relies on this ordering!!!
+  eFamily_sans_serif,
+  eFamily_monospace,
+  eFamily_cursive,
+  eFamily_fantasy,
+
+  // special
+  eFamily_moz_variable,
+  eFamily_moz_fixed,
+
+  eFamily_generic_first = eFamily_serif,
+  eFamily_generic_last = eFamily_fantasy,
+  eFamily_generic_count = (eFamily_fantasy - eFamily_serif + 1)
+};
+
+enum QuotedName { eQuotedName, eUnquotedName };
+
+/**
+ * font family name, a string for the name if not a generic and
+ * a font type indicated named family or which generic family
+ */
+
+struct FontFamilyName final {
+    FontFamilyName()
+        : mType(eFamily_named)
+    {}
+
+    // named font family - e.g. Helvetica
+    explicit FontFamilyName(const nsAString& aFamilyName,
+                            QuotedName aQuoted = eUnquotedName) {
+        mType = (aQuoted == eQuotedName) ? eFamily_named_quoted : eFamily_named;
+        mName = aFamilyName;
+    }
+
+    // generic font family - e.g. sans-serif
+    explicit FontFamilyName(FontFamilyType aType) {
+        NS_ASSERTION(aType != eFamily_named &&
+                     aType != eFamily_named_quoted &&
+                     aType != eFamily_none,
+                     "expected a generic font type");
+        mName.Truncate();
+        mType = aType;
+    }
+
+    FontFamilyName(const FontFamilyName& aCopy) {
+        mType = aCopy.mType;
+        mName = aCopy.mName;
+    }
+
+    bool IsNamed() const {
+        return mType == eFamily_named || mType == eFamily_named_quoted;
+    }
+
+    bool IsGeneric() const {
+        return !IsNamed();
+    }
+
+    void AppendToString(nsAString& aFamilyList, bool aQuotes = true) const {
+        switch (mType) {
+            case eFamily_named:
+                aFamilyList.Append(mName);
+                break;
+            case eFamily_named_quoted:
+                if (aQuotes) {
+                    aFamilyList.Append('"');
+                }
+                aFamilyList.Append(mName);
+                if (aQuotes) {
+                    aFamilyList.Append('"');
+                }
+                break;
+            case eFamily_serif:
+                aFamilyList.AppendLiteral("serif");
+                break;
+            case eFamily_sans_serif:
+                aFamilyList.AppendLiteral("sans-serif");
+                break;
+            case eFamily_monospace:
+                aFamilyList.AppendLiteral("monospace");
+                break;
+            case eFamily_cursive:
+                aFamilyList.AppendLiteral("cursive");
+                break;
+            case eFamily_fantasy:
+                aFamilyList.AppendLiteral("fantasy");
+                break;
+            case eFamily_moz_fixed:
+                aFamilyList.AppendLiteral("-moz-fixed");
+                break;
+            default:
+                break;
+        }
+    }
+
+    // helper method that converts generic names to the right enum value
+    static FontFamilyName
+    Convert(const nsAString& 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");
+
+        FontFamilyType genericType = eFamily_none;
+        if (aFamilyOrGenericName.LowerCaseEqualsLiteral("serif")) {
+            genericType = eFamily_serif;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("sans-serif")) {
+            genericType = eFamily_sans_serif;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("monospace")) {
+            genericType = eFamily_monospace;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("cursive")) {
+            genericType = eFamily_cursive;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("fantasy")) {
+            genericType = eFamily_fantasy;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("-moz-fixed")) {
+            genericType = eFamily_moz_fixed;
+        } else {
+            return FontFamilyName(aFamilyOrGenericName, eUnquotedName);
+        }
+
+        return FontFamilyName(genericType);
+    }
+
+    // memory reporting
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+        return mName.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+    }
+
+    FontFamilyType mType;
+    nsString       mName; // empty if mType != eFamily_named
+};
+
+inline bool
+operator==(const FontFamilyName& a, const FontFamilyName& b) {
+    return a.mType == b.mType && a.mName == b.mName;
+}
+
+/**
+ * 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 {
+public:
+    FontFamilyList()
+        : mDefaultFontType(eFamily_none)
+    {
+    }
+
+    explicit FontFamilyList(FontFamilyType aGenericType)
+        : mDefaultFontType(eFamily_none)
+    {
+        Append(FontFamilyName(aGenericType));
+    }
+
+    FontFamilyList(const nsAString& aFamilyName,
+                   QuotedName aQuoted)
+        : mDefaultFontType(eFamily_none)
+    {
+        Append(FontFamilyName(aFamilyName, aQuoted));
+    }
+
+    FontFamilyList(const FontFamilyList& aOther)
+        : mFontlist(aOther.mFontlist)
+        , mDefaultFontType(aOther.mDefaultFontType)
+    {
+    }
+
+    void Append(const FontFamilyName& aFamilyName) {
+        mFontlist.AppendElement(aFamilyName);
+    }
+
+    void Append(const nsTArray<nsString>& aFamilyNameList) {
+        uint32_t len = aFamilyNameList.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            mFontlist.AppendElement(FontFamilyName(aFamilyNameList[i],
+                                                   eUnquotedName));
+        }
+    }
+
+    void Clear() {
+        mFontlist.Clear();
+    }
+
+    uint32_t Length() const {
+        return mFontlist.Length();
+    }
+
+    bool IsEmpty() const {
+      return mFontlist.IsEmpty();
+    }
+
+    const nsTArray<FontFamilyName>& GetFontlist() const {
+        return mFontlist;
+    }
+
+    bool Equals(const FontFamilyList& aFontlist) const {
+        return mFontlist == aFontlist.mFontlist &&
+               mDefaultFontType == aFontlist.mDefaultFontType;
+    }
+
+    FontFamilyType FirstGeneric() const {
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName& name = mFontlist[i];
+            if (name.IsGeneric()) {
+                return name.mType;
+            }
+        }
+        return eFamily_none;
+    }
+
+    bool HasGeneric() const {
+        return FirstGeneric() != eFamily_none;
+    }
+
+    bool HasDefaultGeneric() const {
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName& name = mFontlist[i];
+            if (name.mType == 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.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName name = mFontlist[i];
+            if (name.IsGeneric()) {
+                if (name.mType == eFamily_cursive ||
+                    name.mType == eFamily_fantasy) {
+                    continue;
+                }
+                if (i > 0) {
+                    mFontlist.RemoveElementAt(i);
+                    mFontlist.InsertElementAt(0, name);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void PrependGeneric(FontFamilyType aType) {
+        mFontlist.InsertElementAt(0, FontFamilyName(aType));
+    }
+
+    void ToString(nsAString& aFamilyList,
+                  bool aQuotes = true,
+                  bool aIncludeDefault = false) const {
+        aFamilyList.Truncate();
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            if (i != 0) {
+                aFamilyList.Append(',');
+            }
+            const FontFamilyName& name = mFontlist[i];
+            name.AppendToString(aFamilyList, aQuotes);
+        }
+        if (aIncludeDefault && mDefaultFontType != eFamily_none) {
+            if (!aFamilyList.IsEmpty()) {
+                aFamilyList.Append(',');
+            }
+            if (mDefaultFontType == eFamily_serif) {
+                aFamilyList.AppendLiteral("serif");
+            } else {
+                aFamilyList.AppendLiteral("sans-serif");
+            }
+        }
+    }
+
+    // searches for a specific non-generic name, lowercase comparison
+    bool Contains(const nsAString& aFamilyName) const {
+        uint32_t len = mFontlist.Length();
+        nsAutoString fam(aFamilyName);
+        ToLowerCase(fam);
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName& name = mFontlist[i];
+            if (name.mType != eFamily_named &&
+                name.mType != eFamily_named_quoted) {
+                continue;
+            }
+            nsAutoString listname(name.mName);
+            ToLowerCase(listname);
+            if (listname.Equals(fam)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    FontFamilyType GetDefaultFontType() const { return mDefaultFontType; }
+    void SetDefaultFontType(FontFamilyType aType) {
+        NS_ASSERTION(aType == eFamily_none || aType == eFamily_serif ||
+                     aType == eFamily_sans_serif,
+                     "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.ShallowSizeOfExcludingThis(aMallocSizeOf);
+        for (size_t i = 0; i < mFontlist.Length(); i++) {
+            n += mFontlist[i].SizeOfExcludingThis(aMallocSizeOf);
+        }
+        return n;
+    }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+        return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+    }
+
+private:
+    nsTArray<FontFamilyName>   mFontlist;
+    FontFamilyType             mDefaultFontType; // none, serif or sans-serif
+};
+
+inline bool
+operator==(const FontFamilyList& a, const FontFamilyList& b) {
+    return a.Equals(b);
+}
+
+} // namespace mozilla
+
+#endif /* GFX_FONT_FAMILY_LIST_H */