mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 09:15:35 +00:00
69790bc62e
The inclusions were removed with the following very crude script and the resulting breakage was fixed up by hand. The manual fixups did either revert the changes done by the script, replace a generic header with a more specific one or replace a header with a forward declaration. find . -name "*.idl" | grep -v web-platform | grep -v third_party | while read path; do interfaces=$(grep "^\(class\|interface\).*:.*" "$path" | cut -d' ' -f2) if [ -n "$interfaces" ]; then if [[ "$interfaces" == *$'\n'* ]]; then regexp="\(" for i in $interfaces; do regexp="$regexp$i\|"; done regexp="${regexp%%\\\|}\)" else regexp="$interfaces" fi interface=$(basename "$path") rg -l "#include.*${interface%%.idl}.h" . | while read path2; do hits=$(grep -v "#include.*${interface%%.idl}.h" "$path2" | grep -c "$regexp" ) if [ $hits -eq 0 ]; then echo "Removing ${interface} from ${path2}" grep -v "#include.*${interface%%.idl}.h" "$path2" > "$path2".tmp mv -f "$path2".tmp "$path2" fi done fi done Differential Revision: https://phabricator.services.mozilla.com/D55443 --HG-- extra : moz-landing-system : lando
235 lines
7.1 KiB
C++
235 lines
7.1 KiB
C++
/* -*- 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_INFO_LOADER_H
|
|
#define GFX_FONT_INFO_LOADER_H
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsITimer.h"
|
|
#include "nsIThread.h"
|
|
#include "nsRefPtrHashtable.h"
|
|
#include "nsString.h"
|
|
#include "gfxFont.h"
|
|
#include "mozilla/Atomics.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "nsISupportsImpl.h"
|
|
|
|
// data retrieved for a given face
|
|
|
|
struct FontFaceData {
|
|
FontFaceData() : mUVSOffset(0) {}
|
|
|
|
FontFaceData(const FontFaceData& aFontFaceData) {
|
|
mFullName = aFontFaceData.mFullName;
|
|
mPostscriptName = aFontFaceData.mPostscriptName;
|
|
mCharacterMap = aFontFaceData.mCharacterMap;
|
|
mUVSOffset = aFontFaceData.mUVSOffset;
|
|
}
|
|
|
|
nsCString mFullName;
|
|
nsCString mPostscriptName;
|
|
RefPtr<gfxCharacterMap> mCharacterMap;
|
|
uint32_t mUVSOffset;
|
|
};
|
|
|
|
// 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)
|
|
: mCanceled(false),
|
|
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 nsACString& 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 nsACString& aFontName,
|
|
uint32_t& aUVSOffset) {
|
|
FontFaceData faceData;
|
|
if (!mFontFaceData.Get(aFontName, &faceData) || !faceData.mCharacterMap) {
|
|
return nullptr;
|
|
}
|
|
|
|
aUVSOffset = faceData.mUVSOffset;
|
|
RefPtr<gfxCharacterMap> cmap = faceData.mCharacterMap;
|
|
return cmap.forget();
|
|
}
|
|
|
|
// fetches fullname/postscript names from cached font data
|
|
virtual void GetFaceNames(const nsACString& aFontName, nsACString& aFullName,
|
|
nsACString& 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 nsACString& aFamilyName,
|
|
nsTArray<nsCString>& aOtherFamilyNames) {
|
|
return mOtherFamilyNames.Get(aFamilyName, &aOtherFamilyNames);
|
|
}
|
|
|
|
nsTArray<nsCString> mFontFamiliesToLoad;
|
|
|
|
// currently non-issue but beware,
|
|
// this is also set during cleanup after finishing
|
|
mozilla::Atomic<bool> mCanceled;
|
|
|
|
// 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<nsCStringHashKey, FontFaceData> mFontFaceData;
|
|
|
|
// canonical family name ==> array of localized family names
|
|
nsDataHashtable<nsCStringHashKey, nsTArray<nsCString> > 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() = default;
|
|
|
|
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
|
|
RefPtr<FontInfoData> mFontInfo;
|
|
|
|
// time spent on the loader thread
|
|
mozilla::TimeDuration mLoadTime;
|
|
};
|
|
|
|
#endif /* GFX_FONT_INFO_LOADER_H */
|