The Tor Browser: gfx/thebes/gfxFontInfoLoader.h@97036ab72558 (annotated)

gfx/thebes/gfxFontInfoLoader.h@97036ab72558 (annotated)

gfx/thebes/gfxFontInfoLoader.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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 / annotate

gfx/thebes/gfxFontInfoLoader.h@97036ab72558 (annotated)

gfx/thebes/gfxFontInfoLoader.h