commit 083d98d73379f864a0d3cb9695e7c7ad0febce1c
author Jan-Marek Glogowski <jan-marek.glogowski@extern.cib.de> Sat Nov 16 02:21:26 2019 +0000
committer Michael Weghorn <m.weghorn@posteo.de> Thu Nov 21 15:21:05 2019 +0100
tree b1840a92ea99ff939df6ebce0081e9250181c989
parent d7680512046b41bcf57e4f1b21420a3ea0190bf4

tdf#128434 try garbage collect ImplFontCache fonts

Instead of changing the harfbuzz caching, for this use case it's
enough to queue all per-OutputDevice fonts for garbage collection
(GC), which are managed by the OutputDevices ImplFontCache. So
just try to GC all the fonts in the ImplFontCache destructor.

There is no point keeping these LogicalFontInstances alive, after
the OutputDevice font cache is destroyed, as these fonts aren't
shared and can't be accessed later. But the main problem is still
some correct accounting of harfbuzz resources and eventual even
the Freetype ones, so this cleanup would not really be needed.

AFAI can tell, this plugs the remaining per-document leaks of the
PDF generation, except for a 72 byte basic listener leak from:

basic::ImplRepository::impl_createManagerForModel(...)
    basicmanagerrepository.cxx:480

Change-Id: I3155be59a2bdcd85e01f6f048b990db04d88c94f
Reviewed-on: https://gerrit.libreoffice.org/82968
Tested-by: Jenkins
Reviewed-by: Jan-Marek Glogowski <glogow@fbihome.de>
(cherry picked from commit e6aac0b637d583d3cfb893276f813ff5aa1ade17)
Reviewed-on: https://gerrit.libreoffice.org/83148
(cherry picked from commit 325005697155853891ce4f23e7349931e748d7e7)
Reviewed-on: https://gerrit.libreoffice.org/83196
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>

vcl/inc/unx/glyphcache.hxx

diff --git a/vcl/inc/unx/glyphcache.hxx b/vcl/inc/unx/glyphcache.hxx
index cf225ed..f2d9c77 100644
--- a/vcl/inc/unx/glyphcache.hxx
+++ b/vcl/inc/unx/glyphcache.hxx
@@ -93,6 +93,19 @@ public:

    FreetypeFont*           CacheFont(LogicalFontInstance* pFontInstance);
    void                    UncacheFont( FreetypeFont& );

    /** Try to GarbageCollect an explicit logical font
     *
     * This should just be called from the ~ImplFontCache destructor, which holds the mapping of the
     * FontSelectPattern to the LogicalFontInstance per OutputDevice. All other users should just
     * call CacheFont and UncacheFont correctly. When the ImplFontCache is destroyed with its
     * OutputDevice, we can safely garbage collection its unused entries, as these can't be reused.
     *
     * It's always safe to call this, as it just ignores the used bytes when considering a font for
     * garbage collection, which normally keeps unreferenced fonts alive.
     **/
    void TryGarbageCollectFont(LogicalFontInstance*);

    void                    ClearFontCache();
    void                    ClearFontOptions();

vcl/source/font/fontcache.cxx

diff --git a/vcl/source/font/fontcache.cxx b/vcl/source/font/fontcache.cxx
index abcee23..dccce0c 100644
--- a/vcl/source/font/fontcache.cxx
+++ b/vcl/source/font/fontcache.cxx
@@ -26,6 +26,10 @@
#include <PhysicalFontFamily.hxx>
#include <sal/log.hxx>

#if !(defined(_WIN32) || defined(MACOSX) || defined(IOS))
#include <unx/glyphcache.hxx>
#endif

size_t ImplFontCache::IFSD_Hash::operator()( const FontSelectPattern& rFSD ) const
{
    return rFSD.hashCode();
@@ -93,7 +97,12 @@ ImplFontCache::ImplFontCache()
ImplFontCache::~ImplFontCache()
{
    for (const auto & rLFI : maFontInstanceList)
    {
#if !(defined(_WIN32) || defined(MACOSX) || defined(IOS))
        GlyphCache::GetInstance().TryGarbageCollectFont(rLFI.second.get());
#endif
        rLFI.second->mpFontCache = nullptr;
    }
}

rtl::Reference<LogicalFontInstance> ImplFontCache::GetFontInstance( PhysicalFontCollection const * pFontList,

vcl/unx/generic/glyphs/glyphcache.cxx

diff --git a/vcl/unx/generic/glyphs/glyphcache.cxx b/vcl/unx/generic/glyphs/glyphcache.cxx
index 18fb60b..28fdaa8 100644
--- a/vcl/unx/generic/glyphs/glyphcache.cxx
+++ b/vcl/unx/generic/glyphs/glyphcache.cxx
@@ -204,6 +204,21 @@ void GlyphCache::UncacheFont( FreetypeFont& rFreetypeFont )
    }
}

void GlyphCache::TryGarbageCollectFont(LogicalFontInstance *pFontInstance)
{
    if (maFontList.empty() || !pFontInstance)
        return;
    FreetypeFontInstance* pFFI = dynamic_cast<FreetypeFontInstance*>(pFontInstance);
    if (!pFFI)
        return;
    FreetypeFont* pFreetypeFont = pFFI->GetFreetypeFont();
    if (pFreetypeFont && (pFreetypeFont->GetRefCount() <= 0))
    {
        mpCurrentGCFont = pFreetypeFont;
        GarbageCollect();
    }
}

void GlyphCache::GarbageCollect()
{
    // when current GC font has been destroyed get another one
@@ -241,7 +256,11 @@ void GlyphCache::GarbageCollect()
        if( pFreetypeFont == mpCurrentGCFont )
            mpCurrentGCFont = nullptr;

        maFontList.erase(pFreetypeFont->GetFontInstance());
#ifndef NDEBUG
        int nErased =
#endif
            maFontList.erase(pFreetypeFont->GetFontInstance());
        assert(1 == nErased);
    }
}