The Tor Browser: comparison gfx/thebes/gfxFontInfoLoader.h

--1:000000000000
+:78b07187e364
+/* -*- 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)
+{
+}
+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
+ShutdownObserver(gfxFontInfoLoader *aLoader)
+: mLoader(aLoader)
+{ }
+virtual ~ShutdownObserver()
+{ }
+protected:
+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 */

The Tor Browser / file comparison

comparison: gfx/thebes/gfxFontInfoLoader.h

gfx/thebes/gfxFontInfoLoader.h