Add m-esr52 at 52.6.0

1 files changed, 217 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFT2FontBase.cpp b/gfx/thebes/gfxFT2FontBase.cpp
new file mode 100644
index 000000000..241f28f63
--- /dev/null
+++ b/gfx/thebes/gfxFT2FontBase.cpp
@@ -0,0 +1,217 @@
+/* -*- 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/. */
+
+#include "gfxFT2FontBase.h"
+#include "gfxFT2Utils.h"
+#include "harfbuzz/hb.h"
+#include "mozilla/Likely.h"
+#include "gfxFontConstants.h"
+#include "gfxFontUtils.h"
+
+using namespace mozilla::gfx;
+
+gfxFT2FontBase::gfxFT2FontBase(cairo_scaled_font_t *aScaledFont,
+                               gfxFontEntry *aFontEntry,
+                               const gfxFontStyle *aFontStyle)
+    : gfxFont(aFontEntry, aFontStyle, kAntialiasDefault, aScaledFont),
+      mSpaceGlyph(0),
+      mHasMetrics(false)
+{
+    cairo_scaled_font_reference(mScaledFont);
+    gfxFT2LockedFace face(this);
+    mFUnitsConvFactor = face.XScale();
+}
+
+gfxFT2FontBase::~gfxFT2FontBase()
+{
+    cairo_scaled_font_destroy(mScaledFont);
+}
+
+uint32_t
+gfxFT2FontBase::GetGlyph(uint32_t aCharCode)
+{
+    // FcFreeTypeCharIndex needs to lock the FT_Face and can end up searching
+    // through all the postscript glyph names in the font.  Therefore use a
+    // lightweight cache, which is stored on the cairo_font_face_t.
+
+    cairo_font_face_t *face =
+        cairo_scaled_font_get_font_face(CairoScaledFont());
+
+    if (cairo_font_face_status(face) != CAIRO_STATUS_SUCCESS)
+        return 0;
+
+    // This cache algorithm and size is based on what is done in
+    // cairo_scaled_font_text_to_glyphs and pango_fc_font_real_get_glyph.  I
+    // think the concept is that adjacent characters probably come mostly from
+    // one Unicode block.  This assumption is probably not so valid with
+    // scripts with large character sets as used for East Asian languages.
+
+    struct CmapCacheSlot {
+        uint32_t mCharCode;
+        uint32_t mGlyphIndex;
+    };
+    const uint32_t kNumSlots = 256;
+    static cairo_user_data_key_t sCmapCacheKey;
+
+    CmapCacheSlot *slots = static_cast<CmapCacheSlot*>
+        (cairo_font_face_get_user_data(face, &sCmapCacheKey));
+
+    if (!slots) {
+        // cairo's caches can keep some cairo_font_faces alive past our last
+        // destroy, so the destroy function (free) for the cache must be
+        // callable from cairo without any assumptions about what other
+        // modules have not been shutdown.
+        slots = static_cast<CmapCacheSlot*>
+            (calloc(kNumSlots, sizeof(CmapCacheSlot)));
+        if (!slots)
+            return 0;
+
+        cairo_status_t status =
+            cairo_font_face_set_user_data(face, &sCmapCacheKey, slots, free);
+        if (status != CAIRO_STATUS_SUCCESS) { // OOM
+            free(slots);
+            return 0;
+        }
+
+        // Invalidate slot 0 by setting its char code to something that would
+        // never end up in slot 0.  All other slots are already invalid
+        // because they have mCharCode = 0 and a glyph for char code 0 will
+        // always be in the slot 0.
+        slots[0].mCharCode = 1;
+    }
+
+    CmapCacheSlot *slot = &slots[aCharCode % kNumSlots];
+    if (slot->mCharCode != aCharCode) {
+        slot->mCharCode = aCharCode;
+        slot->mGlyphIndex = gfxFT2LockedFace(this).GetGlyph(aCharCode);
+    }
+
+    return slot->mGlyphIndex;
+}
+
+void
+gfxFT2FontBase::GetGlyphExtents(uint32_t aGlyph, cairo_text_extents_t* aExtents)
+{
+    NS_PRECONDITION(aExtents != nullptr, "aExtents must not be NULL");
+
+    cairo_glyph_t glyphs[1];
+    glyphs[0].index = aGlyph;
+    glyphs[0].x = 0.0;
+    glyphs[0].y = 0.0;
+    // cairo does some caching for us here but perhaps a small gain could be
+    // made by caching more.  It is usually only the advance that is needed,
+    // so caching only the advance could allow many requests to be cached with
+    // little memory use.  Ideally this cache would be merged with
+    // gfxGlyphExtents.
+    cairo_scaled_font_glyph_extents(CairoScaledFont(), glyphs, 1, aExtents);
+}
+
+const gfxFont::Metrics&
+gfxFT2FontBase::GetHorizontalMetrics()
+{
+    if (mHasMetrics)
+        return mMetrics;
+
+    if (MOZ_UNLIKELY(GetStyle()->size <= 0.0) ||
+        MOZ_UNLIKELY(GetStyle()->sizeAdjust == 0.0)) {
+        new(&mMetrics) gfxFont::Metrics(); // zero initialize
+        mSpaceGlyph = GetGlyph(' ');
+    } else {
+        gfxFT2LockedFace face(this);
+        face.GetMetrics(&mMetrics, &mSpaceGlyph);
+    }
+
+    SanitizeMetrics(&mMetrics, false);
+
+#if 0
+    //    printf("font name: %s %f\n", NS_ConvertUTF16toUTF8(GetName()).get(), GetStyle()->size);
+    //    printf ("pango font %s\n", pango_font_description_to_string (pango_font_describe (font)));
+
+    fprintf (stderr, "Font: %s\n", NS_ConvertUTF16toUTF8(GetName()).get());
+    fprintf (stderr, "    emHeight: %f emAscent: %f emDescent: %f\n", mMetrics.emHeight, mMetrics.emAscent, mMetrics.emDescent);
+    fprintf (stderr, "    maxAscent: %f maxDescent: %f\n", mMetrics.maxAscent, mMetrics.maxDescent);
+    fprintf (stderr, "    internalLeading: %f externalLeading: %f\n", mMetrics.externalLeading, mMetrics.internalLeading);
+    fprintf (stderr, "    spaceWidth: %f aveCharWidth: %f xHeight: %f\n", mMetrics.spaceWidth, mMetrics.aveCharWidth, mMetrics.xHeight);
+    fprintf (stderr, "    uOff: %f uSize: %f stOff: %f stSize: %f\n", mMetrics.underlineOffset, mMetrics.underlineSize, mMetrics.strikeoutOffset, mMetrics.strikeoutSize);
+#endif
+
+    mHasMetrics = true;
+    return mMetrics;
+}
+
+// Get the glyphID of a space
+uint32_t
+gfxFT2FontBase::GetSpaceGlyph()
+{
+    GetHorizontalMetrics();
+    return mSpaceGlyph;
+}
+
+uint32_t
+gfxFT2FontBase::GetGlyph(uint32_t unicode, uint32_t variation_selector)
+{
+    if (variation_selector) {
+        uint32_t id =
+            gfxFT2LockedFace(this).GetUVSGlyph(unicode, variation_selector);
+        if (id) {
+            return id;
+        }
+        unicode = gfxFontUtils::GetUVSFallback(unicode, variation_selector);
+        if (unicode) {
+            return GetGlyph(unicode);
+        }
+        return 0;
+    }
+
+    return GetGlyph(unicode);
+}
+
+int32_t
+gfxFT2FontBase::GetGlyphWidth(DrawTarget& aDrawTarget, uint16_t aGID)
+{
+    cairo_text_extents_t extents;
+    GetGlyphExtents(aGID, &extents);
+    // convert to 16.16 fixed point
+    return NS_lround(0x10000 * extents.x_advance);
+}
+
+bool
+gfxFT2FontBase::SetupCairoFont(DrawTarget* aDrawTarget)
+{
+    // The scaled font ctm is not relevant right here because
+    // cairo_set_scaled_font does not record the scaled font itself, but
+    // merely the font_face, font_matrix, font_options.  The scaled_font used
+    // for the target can be different from the scaled_font passed to
+    // cairo_set_scaled_font.  (Unfortunately we have measured only for an
+    // identity ctm.)
+    cairo_scaled_font_t *cairoFont = CairoScaledFont();
+
+    if (cairo_scaled_font_status(cairoFont) != CAIRO_STATUS_SUCCESS) {
+        // Don't cairo_set_scaled_font as that would propagate the error to
+        // the cairo_t, precluding any further drawing.
+        return false;
+    }
+    // Thoughts on which font_options to set on the context:
+    //
+    // cairoFont has been created for screen rendering.
+    //
+    // When the context is being used for screen rendering, we should set
+    // font_options such that the same scaled_font gets used (when the ctm is
+    // the same).  The use of explicit font_options recorded in
+    // CreateScaledFont ensures that this will happen.
+    //
+    // XXXkt: For pdf and ps surfaces, I don't know whether it's better to
+    // remove surface-specific options, or try to draw with the same
+    // scaled_font that was used to measure.  As the same font_face is being
+    // used, its font_options will often override some values anyway (unless
+    // perhaps we remove those from the FcPattern at face creation).
+    //
+    // I can't see any significant difference in printing, irrespective of
+    // what is set here.  It's too late to change things here as measuring has
+    // already taken place.  We should really be measuring with a different
+    // font for pdf and ps surfaces (bug 403513).
+    cairo_set_scaled_font(gfxFont::RefCairo(aDrawTarget), cairoFont);
+    return true;
+}