gecko-dev/gfx/thebes/gfxFontInfoLoader.h

/* -*- 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_INFO_LOADER_H
#define GFX_FONT_INFO_LOADER_H

#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsIObserver.h"
#include "nsITimer.h"
#include "nsIThread.h"
#include "nsRefPtrHashtable.h"
#include "nsString.h"
#include "gfxFont.h"
#include "nsIRunnable.h"
#include "mozilla/TimeStamp.h"
#include "nsISupportsImpl.h"

// data retrieved for a given face

struct FontFaceData {
    FontFaceData() : mUVSOffset(0), mSymbolFont(false) {}

    FontFaceData(const FontFaceData& aFontFaceData) {
        mFullName = aFontFaceData.mFullName;
        mPostscriptName = aFontFaceData.mPostscriptName;
        mCharacterMap = aFontFaceData.mCharacterMap;
        mUVSOffset = aFontFaceData.mUVSOffset;
        mSymbolFont = aFontFaceData.mSymbolFont;
    }

    nsString mFullName;
    nsString mPostscriptName;
    nsRefPtr<gfxCharacterMap> mCharacterMap;
    uint32_t mUVSOffset;
    bool mSymbolFont;
};

// base class used to contain cached system-wide font info.
// methods in this class are called on off-main threads so
// all methods use only static methods or other thread-safe
// font data access API's. specifically, no use is made of
// gfxPlatformFontList, gfxFontFamily, gfxFamily or any
// harfbuzz API methods within FontInfoData subclasses.

class FontInfoData {
public:
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FontInfoData)

    FontInfoData(bool aLoadOtherNames,
                 bool aLoadFaceNames,
                 bool aLoadCmaps) :
        mLoadOtherNames(aLoadOtherNames),
        mLoadFaceNames(aLoadFaceNames),
        mLoadCmaps(aLoadCmaps)
    {
        MOZ_COUNT_CTOR(FontInfoData);
    }

protected:
    // Protected destructor, to discourage deletion outside of Release():
    virtual ~FontInfoData() {
        MOZ_COUNT_DTOR(FontInfoData);
    }

public:
    virtual void Load();

    // loads font data for all fonts of a given family
    // (called on async thread)
    virtual void LoadFontFamilyData(const nsAString& aFamilyName) = 0;

    // -- methods overriden by platform-specific versions --

    // fetches cmap data for a particular font from cached font data
    virtual already_AddRefed<gfxCharacterMap>
    GetCMAP(const nsAString& aFontName,
            uint32_t& aUVSOffset,
            bool& aSymbolFont)
    {
        FontFaceData faceData;
        if (!mFontFaceData.Get(aFontName, &faceData) ||
            !faceData.mCharacterMap) {
            return nullptr;
        }

        aUVSOffset = faceData.mUVSOffset;
        aSymbolFont = faceData.mSymbolFont;
        nsRefPtr<gfxCharacterMap> cmap = faceData.mCharacterMap;
        return cmap.forget();
    }

    // fetches fullname/postscript names from cached font data
    virtual void GetFaceNames(const nsAString& aFontName,
                              nsAString& aFullName,
                              nsAString& aPostscriptName)
    {
        FontFaceData faceData;
        if (!mFontFaceData.Get(aFontName, &faceData)) {
            return;
        }

        aFullName = faceData.mFullName;
        aPostscriptName = faceData.mPostscriptName;
    }

    // fetches localized family name data from cached font data
    virtual bool GetOtherFamilyNames(const nsAString& aFamilyName,
                                     nsTArray<nsString>& aOtherFamilyNames)
    {
        return mOtherFamilyNames.Get(aFamilyName, &aOtherFamilyNames); 
    }

    nsTArray<nsString> mFontFamiliesToLoad;

    // time spent on the loader thread
    mozilla::TimeDuration mLoadTime;

    struct FontCounts {
        uint32_t families;
        uint32_t fonts;
        uint32_t cmaps;
        uint32_t facenames;
        uint32_t othernames;
    };

    FontCounts mLoadStats;

    bool mLoadOtherNames;
    bool mLoadFaceNames;
    bool mLoadCmaps;

    // face name ==> per-face data
    nsDataHashtable<nsStringHashKey, FontFaceData> mFontFaceData;

    // canonical family name ==> array of localized family names
    nsDataHashtable<nsStringHashKey, nsTArray<nsString> > mOtherFamilyNames;
};

// gfxFontInfoLoader - helper class for loading font info on async thread
// For large, "all fonts on system" data, data needed on a given platform
// (e.g. localized names, face names, cmaps) are loaded async.

// helper class for loading in font info on a separate async thread
// once async thread completes, completion process is run on regular
// intervals to prevent tying up the main thread

class gfxFontInfoLoader {
public:

    // state transitions:
    //   initial ---StartLoader with delay---> timer on delay
    //   initial ---StartLoader without delay---> timer on interval
    //   timer on delay ---LoaderTimerFire---> timer on interval
    //   timer on delay ---CancelLoader---> timer off
    //   timer on interval ---CancelLoader---> timer off
    //   timer off ---StartLoader with delay---> timer on delay
    //   timer off ---StartLoader without delay---> timer on interval
    typedef enum {
        stateInitial,
        stateTimerOnDelay,
        stateAsyncLoad,
        stateTimerOnInterval,
        stateTimerOff
    } TimerState;

    gfxFontInfoLoader() :
        mInterval(0), mState(stateInitial)
    {
        MOZ_COUNT_CTOR(gfxFontInfoLoader);
    }

    virtual ~gfxFontInfoLoader();

    // start timer with an initial delay, then call Run method at regular intervals
    void StartLoader(uint32_t aDelay, uint32_t aInterval);

    // Finalize - async load complete, transfer data (on intervals if necessary)
    virtual void FinalizeLoader(FontInfoData *aFontInfo);

    // cancel the timer and cleanup
    void CancelLoader();

    uint32_t GetInterval() { return mInterval; }

protected:
    class ShutdownObserver : public nsIObserver
    {
    public:
        NS_DECL_ISUPPORTS
        NS_DECL_NSIOBSERVER

        explicit ShutdownObserver(gfxFontInfoLoader *aLoader)
            : mLoader(aLoader)
        { }

    protected:
        virtual ~ShutdownObserver()
        { }

        gfxFontInfoLoader *mLoader;
    };

    // CreateFontInfo - create platform-specific object used
    //                  to load system-wide font info
    virtual already_AddRefed<FontInfoData> CreateFontInfoData() {
        return nullptr;
    }

    // Init - initialization before async loader thread runs
    virtual void InitLoader() = 0;

    // LoadFontInfo - transfer font info data within a time limit, return
    //                true when done
    virtual bool LoadFontInfo() = 0;

    // Cleanup - finish and cleanup after done, including possible reflows
    virtual void CleanupLoader() {
        mFontInfo = nullptr;
    }

    // Timer interval callbacks
    static void LoadFontInfoCallback(nsITimer *aTimer, void *aThis) {
        gfxFontInfoLoader *loader = static_cast<gfxFontInfoLoader*>(aThis);
        loader->LoadFontInfoTimerFire();
    }

    static void DelayedStartCallback(nsITimer *aTimer, void *aThis) {
        gfxFontInfoLoader *loader = static_cast<gfxFontInfoLoader*>(aThis);
        loader->StartLoader(0, loader->GetInterval());
    }

    void LoadFontInfoTimerFire();

    void AddShutdownObserver();
    void RemoveShutdownObserver();

    nsCOMPtr<nsITimer> mTimer;
    nsCOMPtr<nsIObserver> mObserver;
    nsCOMPtr<nsIThread> mFontLoaderThread;
    uint32_t mInterval;
    TimerState mState;

    // after async font loader completes, data is stored here
    nsRefPtr<FontInfoData> mFontInfo;

    // time spent on the loader thread
    mozilla::TimeDuration mLoadTime;
};

#endif /* GFX_FONT_INFO_LOADER_H */