The Tor Browser: layout/base/nsPresContext.h@6474c204b198 (annotated)

layout/base/nsPresContext.h@6474c204b198 (annotated)

layout/base/nsPresContext.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; 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/. */
 /* a presentation of a document, part 1 */
 #ifndef nsPresContext_h___
 #define nsPresContext_h___
 #include "mozilla/Attributes.h"
 #include "mozilla/WeakPtr.h"
 #include "nsColor.h"
 #include "nsCoord.h"
 #include "nsCOMPtr.h"
 #include "nsIPresShell.h"
 #include "nsRect.h"
 #include "nsFont.h"
 #include "gfxFontConstants.h"
 #include "nsIAtom.h"
 #include "nsIObserver.h"
 #include "nsITimer.h"
 #include "nsCRT.h"
 #include "FramePropertyTable.h"
 #include "nsGkAtoms.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsChangeHint.h"
 #include <algorithm>
 // This also pulls in gfxTypes.h, which we cannot include directly.
 #include "gfxRect.h"
 #include "nsTArray.h"
 #include "nsAutoPtr.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/AppUnits.h"
 #include "prclist.h"
 #include "nsThreadUtils.h"
 #include "ScrollbarStyles.h"
 class nsBidiPresUtils;
 class nsAString;
 class nsIPrintSettings;
 class nsDocShell;
 class nsIDocShell;
 class nsIDocument;
 class nsILanguageAtomService;
 class nsITheme;
 class nsIContent;
 class nsIFrame;
 class nsFrameManager;
 class nsILinkHandler;
 class nsIAtom;
 class nsICSSPseudoComparator;
 struct nsStyleBackground;
 struct nsStyleBorder;
 class nsIRunnable;
 class gfxUserFontSet;
 class gfxTextPerfMetrics;
 class nsUserFontSet;
 struct nsFontFaceRuleContainer;
 class nsObjectFrame;
 class nsTransitionManager;
 class nsAnimationManager;
 class nsRefreshDriver;
 class nsIWidget;
 class nsDeviceContext;
 namespace mozilla {
 class EventStateManager;
 class RestyleManager;
 namespace dom {
 class MediaQueryList;
 }
 namespace layers {
 class ContainerLayer;
 }
 }
 // supported values for cached bool types
 enum nsPresContext_CachedBoolPrefType {
   kPresContext_UseDocumentColors = 1,
   kPresContext_UseDocumentFonts,
   kPresContext_UnderlineLinks
 };
 // supported values for cached integer pref types
 enum nsPresContext_CachedIntPrefType {
   kPresContext_ScrollbarSide = 1,
   kPresContext_BidiDirection
 };
 // IDs for the default variable and fixed fonts (not to be changed, see nsFont.h)
 // To be used for Get/SetDefaultFont(). The other IDs in nsFont.h are also supported.
 const uint8_t kPresContext_DefaultVariableFont_ID = 0x00; // kGenericFont_moz_variable
 const uint8_t kPresContext_DefaultFixedFont_ID    = 0x01; // kGenericFont_moz_fixed
 #ifdef DEBUG
 struct nsAutoLayoutPhase;
 enum nsLayoutPhase {
   eLayoutPhase_Paint,
   eLayoutPhase_Reflow,
   eLayoutPhase_FrameC,
   eLayoutPhase_COUNT
 };
 #endif
 class nsInvalidateRequestList {
 public:
   struct Request {
     nsRect   mRect;
     uint32_t mFlags;
   };
   void TakeFrom(nsInvalidateRequestList* aList)
   {
     mRequests.MoveElementsFrom(aList->mRequests);
   }
   bool IsEmpty() { return mRequests.IsEmpty(); }
   nsTArray<Request> mRequests;
 };
 /* Used by nsPresContext::HasAuthorSpecifiedRules */
 #define NS_AUTHOR_SPECIFIED_BACKGROUND      (1 << 0)
 #define NS_AUTHOR_SPECIFIED_BORDER          (1 << 1)
 #define NS_AUTHOR_SPECIFIED_PADDING         (1 << 2)
 #define NS_AUTHOR_SPECIFIED_TEXT_SHADOW     (1 << 3)
 class nsRootPresContext;
 // An interface for presentation contexts. Presentation contexts are
 // objects that provide an outer context for a presentation shell.
 class nsPresContext : public nsIObserver {
 public:
   typedef mozilla::FramePropertyTable FramePropertyTable;
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_NSIOBSERVER
   NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
   NS_DECL_CYCLE_COLLECTION_CLASS(nsPresContext)
   enum nsPresContextType {
     eContext_Galley,       // unpaginated screen presentation
     eContext_PrintPreview, // paginated screen presentation
     eContext_Print,        // paginated printer presentation
     eContext_PageLayout    // paginated & editable.
   };
   // Policies for rebuilding style data.
   enum StyleRebuildType {
     eRebuildStyleIfNeeded,
     eAlwaysRebuildStyle
   };
   nsPresContext(nsIDocument* aDocument, nsPresContextType aType) NS_HIDDEN;
   /**
    * Initialize the presentation context from a particular device.
    */
   NS_HIDDEN_(nsresult) Init(nsDeviceContext* aDeviceContext);
   /**
    * Set the presentation shell that this context is bound to.
    * A presentation context may only be bound to a single shell.
    */
   NS_HIDDEN_(void) SetShell(nsIPresShell* aShell);
   NS_HIDDEN_(nsPresContextType) Type() const { return mType; }
   /**
    * Get the PresentationShell that this context is bound to.
    */
   nsIPresShell* PresShell() const
   {
     NS_ASSERTION(mShell, "Null pres shell");
     return mShell;
   }
   nsIPresShell* GetPresShell() const { return mShell; }
   /**
    * Returns the parent prescontext for this one. Returns null if this is a
    * root.
    */
   nsPresContext* GetParentPresContext();
   /**
    * Returns the prescontext of the toplevel content document that contains
    * this presentation, or null if there isn't one.
    */
   nsPresContext* GetToplevelContentDocumentPresContext();
   /**
    * Returns the nearest widget for the root frame of this.
    *
    * @param aOffset     If non-null the offset from the origin of the root
    *                    frame's view to the widget's origin (usually positive)
    *                    expressed in appunits of this will be returned in
    *                    aOffset.
    */
   nsIWidget* GetNearestWidget(nsPoint* aOffset = nullptr);
   /**
    * Returns the root widget for this.
    * Note that the widget is a mediater with IME.
    */
   nsIWidget* GetRootWidget();
   /**
    * Return the presentation context for the root of the view manager
    * hierarchy that contains this presentation context, or nullptr if it can't
    * be found (e.g. it's detached).
    */
   nsRootPresContext* GetRootPresContext();
   nsRootPresContext* GetDisplayRootPresContext();
   virtual bool IsRoot() { return false; }
   nsIDocument* Document() const
   {
       NS_ASSERTION(!mShell || !mShell->GetDocument() ||
                    mShell->GetDocument() == mDocument,
                    "nsPresContext doesn't have the same document as nsPresShell!");
       return mDocument;
   }
 #ifdef MOZILLA_INTERNAL_API
   nsStyleSet* StyleSet() { return GetPresShell()->StyleSet(); }
   nsFrameManager* FrameManager()
     { return PresShell()->FrameManager(); }
   nsCSSFrameConstructor* FrameConstructor()
     { return PresShell()->FrameConstructor(); }
   nsTransitionManager* TransitionManager() { return mTransitionManager; }
   nsAnimationManager* AnimationManager() { return mAnimationManager; }
   nsRefreshDriver* RefreshDriver() { return mRefreshDriver; }
   mozilla::RestyleManager* RestyleManager() { return mRestyleManager; }
 #endif
   /**
    * Rebuilds all style data by throwing out the old rule tree and
    * building a new one, and additionally applying aExtraHint (which
    * must not contain nsChangeHint_ReconstructFrame) to the root frame.
    * Also rebuild the user font set.
    */
   void RebuildAllStyleData(nsChangeHint aExtraHint);
   /**
    * Just like RebuildAllStyleData, except (1) asynchronous and (2) it
    * doesn't rebuild the user font set.
    */
   void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint);
   void MediaFeatureValuesChanged(StyleRebuildType aShouldRebuild,
                                  nsChangeHint aChangeHint = nsChangeHint(0));
   void PostMediaFeatureValuesChangedEvent();
   NS_HIDDEN_(void) HandleMediaFeatureValuesChangedEvent();
   void FlushPendingMediaFeatureValuesChanged() {
     if (mPendingMediaFeatureValuesChanged)
       MediaFeatureValuesChanged(eRebuildStyleIfNeeded);
   }
   /**
    * Support for window.matchMedia()
    */
   already_AddRefed<mozilla::dom::MediaQueryList>
     MatchMedia(const nsAString& aMediaQueryList);
   /**
    * Access compatibility mode for this context.  This is the same as
    * our document's compatibility mode.
    */
   nsCompatibility CompatibilityMode() const;
   /**
    * Notify the context that the document's compatibility mode has changed
    */
   NS_HIDDEN_(void) CompatibilityModeChanged();
   /**
    * Access the image animation mode for this context
    */
   uint16_t     ImageAnimationMode() const { return mImageAnimationMode; }
   virtual NS_HIDDEN_(void) SetImageAnimationModeExternal(uint16_t aMode);
   NS_HIDDEN_(void) SetImageAnimationModeInternal(uint16_t aMode);
 #ifdef MOZILLA_INTERNAL_API
   void SetImageAnimationMode(uint16_t aMode)
   { SetImageAnimationModeInternal(aMode); }
 #else
   void SetImageAnimationMode(uint16_t aMode)
   { SetImageAnimationModeExternal(aMode); }
 #endif
   /**
    * Get medium of presentation
    */
   nsIAtom* Medium() {
     if (!mIsEmulatingMedia)
       return mMedium;
     return mMediaEmulated;
   }
   /*
    * Render the document as if being viewed on a device with the specified
    * media type.
    */
   void EmulateMedium(const nsAString& aMediaType);
   /*
    * Restore the viewer's natural medium
    */
   void StopEmulatingMedium();
   void* AllocateFromShell(size_t aSize)
   {
     if (mShell)
       return mShell->AllocateMisc(aSize);
     return nullptr;
   }
   void FreeToShell(size_t aSize, void* aFreeChunk)
   {
     NS_ASSERTION(mShell, "freeing after shutdown");
     if (mShell)
       mShell->FreeMisc(aSize, aFreeChunk);
   }
   /**
    * Get the default font for the given language and generic font ID.
    * If aLanguage is nullptr, the document's language is used.
    *
    * This object is read-only, you must copy the font to modify it.
    *
    * When aFontID is kPresContext_DefaultVariableFontID or
    * kPresContext_DefaultFixedFontID (which equals
    * kGenericFont_moz_fixed, which is used for the -moz-fixed generic),
    * the nsFont returned has its name as a CSS generic family (serif or
    * sans-serif for the former, monospace for the latter), and its size
    * as the default font size for variable or fixed fonts for the
    * language group.
    *
    * For aFontID corresponding to a CSS Generic, the nsFont returned has
    * its name set to that generic font's name, and its size set to
    * the user's preference for font size for that generic and the
    * given language.
    */
   NS_HIDDEN_(const nsFont*) GetDefaultFont(uint8_t aFontID,
                                            nsIAtom *aLanguage) const;
   /** Get a cached boolean pref, by its type */
   // *  - initially created for bugs 31816, 20760, 22963
   bool GetCachedBoolPref(nsPresContext_CachedBoolPrefType aPrefType) const
   {
     // If called with a constant parameter, the compiler should optimize
     // this switch statement away.
     switch (aPrefType) {
     case kPresContext_UseDocumentFonts:
       return mUseDocumentFonts;
     case kPresContext_UseDocumentColors:
       return mUseDocumentColors;
     case kPresContext_UnderlineLinks:
       return mUnderlineLinks;
     default:
       NS_ERROR("Invalid arg passed to GetCachedBoolPref");
     }
     return false;
   }
   /** Get a cached integer pref, by its type */
   // *  - initially created for bugs 30910, 61883, 74186, 84398
   int32_t GetCachedIntPref(nsPresContext_CachedIntPrefType aPrefType) const
   {
     // If called with a constant parameter, the compiler should optimize
     // this switch statement away.
     switch (aPrefType) {
     case kPresContext_ScrollbarSide:
       return mPrefScrollbarSide;
     case kPresContext_BidiDirection:
       return mPrefBidiDirection;
     default:
       NS_ERROR("invalid arg passed to GetCachedIntPref");
     }
     return false;
   }
   /**
    * Get the default colors
    */
   const nscolor DefaultColor() const { return mDefaultColor; }
   const nscolor DefaultBackgroundColor() const { return mBackgroundColor; }
   const nscolor DefaultLinkColor() const { return mLinkColor; }
   const nscolor DefaultActiveLinkColor() const { return mActiveLinkColor; }
   const nscolor DefaultVisitedLinkColor() const { return mVisitedLinkColor; }
   const nscolor FocusBackgroundColor() const { return mFocusBackgroundColor; }
   const nscolor FocusTextColor() const { return mFocusTextColor; }
   /**
    * Body text color, for use in quirks mode only.
    */
   const nscolor BodyTextColor() const { return mBodyTextColor; }
   void SetBodyTextColor(nscolor aColor) { mBodyTextColor = aColor; }
   bool GetUseFocusColors() const { return mUseFocusColors; }
   uint8_t FocusRingWidth() const { return mFocusRingWidth; }
   bool GetFocusRingOnAnything() const { return mFocusRingOnAnything; }
   uint8_t GetFocusRingStyle() const { return mFocusRingStyle; }
   NS_HIDDEN_(void) SetContainer(nsIDocShell* aContainer);
   virtual nsISupports* GetContainerWeakExternal() const;
   nsISupports* GetContainerWeakInternal() const;
 #ifdef MOZILLA_INTERNAL_API
   nsISupports* GetContainerWeak() const
   { return GetContainerWeakInternal(); }
 #else
   nsISupports* GetContainerWeak() const
   { return GetContainerWeakExternal(); }
 #endif
   nsIDocShell* GetDocShell() const;
   // XXX this are going to be replaced with set/get container
   void SetLinkHandler(nsILinkHandler* aHandler) { mLinkHandler = aHandler; }
   nsILinkHandler* GetLinkHandler() { return mLinkHandler; }
   /**
    * Detach this pres context - i.e. cancel relevant timers,
    * SetLinkHandler(null), SetContainer(null) etc.
    * Only to be used by the DocumentViewer.
    */
   virtual void Detach();
   /**
    * Get the visible area associated with this presentation context.
    * This is the size of the visible area that is used for
    * presenting the document. The returned value is in the standard
    * nscoord units (as scaled by the device context).
    */
   nsRect GetVisibleArea() { return mVisibleArea; }
   /**
    * Set the currently visible area. The units for r are standard
    * nscoord units (as scaled by the device context).
    */
   void SetVisibleArea(const nsRect& r) {
     if (!r.IsEqualEdges(mVisibleArea)) {
       mVisibleArea = r;
       // Visible area does not affect media queries when paginated.
       if (!IsPaginated() && HasCachedStyleData()) {
         mPendingViewportChange = true;
         PostMediaFeatureValuesChangedEvent();
       }
     }
   }
   /**
    * Return true if this presentation context is a paginated
    * context.
    */
   bool IsPaginated() const { return mPaginated; }
   /**
    * Sets whether the presentation context can scroll for a paginated
    * context.
    */
   NS_HIDDEN_(void) SetPaginatedScrolling(bool aResult);
   /**
    * Return true if this presentation context can scroll for paginated
    * context.
    */
   bool HasPaginatedScrolling() const { return mCanPaginatedScroll; }
   /**
    * Get/set the size of a page
    */
   nsSize GetPageSize() { return mPageSize; }
   void SetPageSize(nsSize aSize) { mPageSize = aSize; }
   /**
    * Get/set whether this document should be treated as having real pages
    * XXX This raises the obvious question of why a document that isn't a page
    *     is paginated; there isn't a good reason except history
    */
   bool IsRootPaginatedDocument() { return mIsRootPaginatedDocument; }
   void SetIsRootPaginatedDocument(bool aIsRootPaginatedDocument)
     { mIsRootPaginatedDocument = aIsRootPaginatedDocument; }
   /**
   * Get/set the print scaling level; used by nsPageFrame to scale up
   * pages.  Set safe to call before reflow, get guaranteed to be set
   * properly after reflow.
   */
   float GetPageScale() { return mPageScale; }
   void SetPageScale(float aScale) { mPageScale = aScale; }
   /**
   * Get/set the scaling facor to use when rendering the pages for print preview.
   * Only safe to get after print preview set up; safe to set anytime.
   * This is a scaling factor for the display of the print preview.  It
   * does not affect layout.  It only affects the size of the onscreen pages
   * in print preview.
   * XXX Temporary: see http://wiki.mozilla.org/Gecko:PrintPreview
   */
   float GetPrintPreviewScale() { return mPPScale; }
   void SetPrintPreviewScale(float aScale) { mPPScale = aScale; }
   nsDeviceContext* DeviceContext() { return mDeviceContext; }
   mozilla::EventStateManager* EventStateManager() { return mEventManager; }
   nsIAtom* GetLanguageFromCharset() { return mLanguage; }
   float TextZoom() { return mTextZoom; }
   void SetTextZoom(float aZoom) {
     if (aZoom == mTextZoom)
       return;
     mTextZoom = aZoom;
     if (HasCachedStyleData()) {
       // Media queries could have changed, since we changed the meaning
       // of 'em' units in them.
       MediaFeatureValuesChanged(eAlwaysRebuildStyle, NS_STYLE_HINT_REFLOW);
     }
   }
   nsTArray<nsFont> mFontsUsed; // currently for font-count limiting only
   nsTArray<nsFont> mFontsTried; // currently for font-count limiting only
   void AddFontUse(const nsFont &font);
   void AddFontAttempt(const nsFont &font);
   PRBool FontUseCountReached(const nsFont &font);
   PRBool FontAttemptCountReached(const nsFont &font);
   /**
    * Get the minimum font size for the specified language. If aLanguage
    * is nullptr, then the document's language is used.  This combines
    * the language-specific global preference with the per-presentation
    * base minimum font size.
    */
   int32_t MinFontSize(nsIAtom *aLanguage) const {
     const LangGroupFontPrefs *prefs = GetFontPrefsForLang(aLanguage);
     return std::max(mBaseMinFontSize, prefs->mMinimumFontSize);
   }
   /**
    * Get the per-presentation base minimum font size.  This size is
    * independent of the language-specific global preference.
    */
   int32_t BaseMinFontSize() const {
     return mBaseMinFontSize;
   }
   /**
    * Set the per-presentation base minimum font size.  This size is
    * independent of the language-specific global preference.
    */
   void SetBaseMinFontSize(int32_t aMinFontSize) {
     if (aMinFontSize == mBaseMinFontSize)
       return;
     mBaseMinFontSize = aMinFontSize;
     if (HasCachedStyleData()) {
       // Media queries could have changed, since we changed the meaning
       // of 'em' units in them.
       MediaFeatureValuesChanged(eAlwaysRebuildStyle, NS_STYLE_HINT_REFLOW);
     }
   }
   float GetFullZoom() { return mFullZoom; }
   void SetFullZoom(float aZoom);
   nscoord GetAutoQualityMinFontSize() {
     return DevPixelsToAppUnits(mAutoQualityMinFontSizePixelsPref);
   }
   /**
    * Return the device's screen width in inches, for font size
    * inflation.
    *
    * If |aChanged| is non-null, then aChanged is filled in with whether
    * the return value has changed since either:
    *  a. the last time the function was called with non-null aChanged, or
    *  b. the first time the function was called.
    */
   float ScreenWidthInchesForFontInflation(bool* aChanged = nullptr);
   static int32_t AppUnitsPerCSSPixel() { return mozilla::AppUnitsPerCSSPixel(); }
   int32_t AppUnitsPerDevPixel() const;
   static int32_t AppUnitsPerCSSInch() { return mozilla::AppUnitsPerCSSInch(); }
   static nscoord CSSPixelsToAppUnits(int32_t aPixels)
   { return NSToCoordRoundWithClamp(float(aPixels) *
              float(AppUnitsPerCSSPixel())); }
   static nscoord CSSPixelsToAppUnits(float aPixels)
   { return NSToCoordRoundWithClamp(aPixels *
              float(AppUnitsPerCSSPixel())); }
   static int32_t AppUnitsToIntCSSPixels(nscoord aAppUnits)
   { return NSAppUnitsToIntPixels(aAppUnits,
              float(AppUnitsPerCSSPixel())); }
   static float AppUnitsToFloatCSSPixels(nscoord aAppUnits)
   { return NSAppUnitsToFloatPixels(aAppUnits,
              float(AppUnitsPerCSSPixel())); }
   nscoord DevPixelsToAppUnits(int32_t aPixels) const
   { return NSIntPixelsToAppUnits(aPixels, AppUnitsPerDevPixel()); }
   int32_t AppUnitsToDevPixels(nscoord aAppUnits) const
   { return NSAppUnitsToIntPixels(aAppUnits,
              float(AppUnitsPerDevPixel())); }
   int32_t CSSPixelsToDevPixels(int32_t aPixels)
   { return AppUnitsToDevPixels(CSSPixelsToAppUnits(aPixels)); }
   float CSSPixelsToDevPixels(float aPixels)
   {
     return NSAppUnitsToFloatPixels(CSSPixelsToAppUnits(aPixels),
                                    float(AppUnitsPerDevPixel()));
   }
   int32_t DevPixelsToIntCSSPixels(int32_t aPixels)
   { return AppUnitsToIntCSSPixels(DevPixelsToAppUnits(aPixels)); }
   float DevPixelsToFloatCSSPixels(int32_t aPixels)
   { return AppUnitsToFloatCSSPixels(DevPixelsToAppUnits(aPixels)); }
   // If there is a remainder, it is rounded to nearest app units.
   nscoord GfxUnitsToAppUnits(gfxFloat aGfxUnits) const;
   gfxFloat AppUnitsToGfxUnits(nscoord aAppUnits) const;
   gfxRect AppUnitsToGfxUnits(const nsRect& aAppRect) const
   { return gfxRect(AppUnitsToGfxUnits(aAppRect.x),
                    AppUnitsToGfxUnits(aAppRect.y),
                    AppUnitsToGfxUnits(aAppRect.width),
                    AppUnitsToGfxUnits(aAppRect.height)); }
   static nscoord CSSTwipsToAppUnits(float aTwips)
   { return NSToCoordRoundWithClamp(
       mozilla::AppUnitsPerCSSInch() * NS_TWIPS_TO_INCHES(aTwips)); }
   // Margin-specific version, since they often need TwipsToAppUnits
   static nsMargin CSSTwipsToAppUnits(const nsIntMargin &marginInTwips)
   { return nsMargin(CSSTwipsToAppUnits(float(marginInTwips.top)),
                     CSSTwipsToAppUnits(float(marginInTwips.right)),
                     CSSTwipsToAppUnits(float(marginInTwips.bottom)),
                     CSSTwipsToAppUnits(float(marginInTwips.left))); }
   static nscoord CSSPointsToAppUnits(float aPoints)
   { return NSToCoordRound(aPoints * mozilla::AppUnitsPerCSSInch() /
                           POINTS_PER_INCH_FLOAT); }
   nscoord RoundAppUnitsToNearestDevPixels(nscoord aAppUnits) const
   { return DevPixelsToAppUnits(AppUnitsToDevPixels(aAppUnits)); }
   void SetViewportOverflowOverride(uint8_t aX, uint8_t aY)
   {
     mViewportStyleOverflow.mHorizontal = aX;
     mViewportStyleOverflow.mVertical = aY;
   }
   mozilla::ScrollbarStyles GetViewportOverflowOverride()
   {
     return mViewportStyleOverflow;
   }
   /**
    * Set and get methods for controlling the background drawing
   */
   bool GetBackgroundImageDraw() const { return mDrawImageBackground; }
   void   SetBackgroundImageDraw(bool aCanDraw)
   {
     mDrawImageBackground = aCanDraw;
   }
   bool GetBackgroundColorDraw() const { return mDrawColorBackground; }
   void   SetBackgroundColorDraw(bool aCanDraw)
   {
     mDrawColorBackground = aCanDraw;
   }
   /**
    * Getter and setter for OMTA time counters
    */
   bool ThrottledTransitionStyleIsUpToDate() const;
   void TickLastUpdateThrottledTransitionStyle();
   bool ThrottledAnimationStyleIsUpToDate() const;
   void TickLastUpdateThrottledAnimationStyle();
   bool StyleUpdateForAllAnimationsIsUpToDate();
   void TickLastStyleUpdateForAllAnimations();
   /**
    *  Check if bidi enabled (set depending on the presence of RTL
    *  characters or when default directionality is RTL).
    *  If enabled, we should apply the Unicode Bidi Algorithm
    *
    *  @lina 07/12/2000
    */
 #ifdef MOZILLA_INTERNAL_API
   bool BidiEnabled() const { return BidiEnabledInternal(); }
 #else
   bool BidiEnabled() const { return BidiEnabledExternal(); }
 #endif
   virtual bool BidiEnabledExternal() const;
   bool BidiEnabledInternal() const;
   /**
    *  Set bidi enabled. This means we should apply the Unicode Bidi Algorithm
    *
    *  @lina 07/12/2000
    */
   NS_HIDDEN_(void) SetBidiEnabled() const;
   /**
    *  Set visual or implicit mode into the pres context.
    *
    *  Visual directionality is a presentation method that displays text
    *  as if it were a uni-directional, according to the primary display
    *  direction only.
    *
    *  Implicit directionality is a presentation method in which the
    *  direction is determined by the Bidi algorithm according to the
    *  category of the characters and the category of the adjacent
    *  characters, and according to their primary direction.
    *
    *  @lina 05/02/2000
    */
   void SetVisualMode(bool aIsVisual)
   {
     mIsVisual = aIsVisual;
   }
   /**
    *  Check whether the content should be treated as visual.
    *
    *  @lina 05/02/2000
    */
   bool IsVisualMode() const { return mIsVisual; }
 //Mohamed
   /**
    * Set the Bidi options for the presentation context
    */
   NS_HIDDEN_(void) SetBidi(uint32_t aBidiOptions,
                            bool aForceRestyle = false);
   /**
    * Get the Bidi options for the presentation context
    * Not inline so consumers of nsPresContext are not forced to
    * include nsIDocument.
    */
   NS_HIDDEN_(uint32_t) GetBidi() const;
   /**
    * Render only Selection
    */
   void SetIsRenderingOnlySelection(bool aResult)
   {
     mIsRenderingOnlySelection = aResult;
   }
   bool IsRenderingOnlySelection() const { return mIsRenderingOnlySelection; }
   NS_HIDDEN_(bool) IsTopLevelWindowInactive();
   /*
    * Obtain a native them for rendering our widgets (both form controls and html)
    */
   NS_HIDDEN_(nsITheme*) GetTheme();
   /*
    * Notify the pres context that the theme has changed.  An internal switch
    * means it's one of our Mozilla themes that changed (e.g., Modern to Classic).
    * Otherwise, the OS is telling us that the native theme for the platform
    * has changed.
    */
   NS_HIDDEN_(void) ThemeChanged();
   /*
    * Notify the pres context that the resolution of the user interface has
    * changed. This happens if a window is moved between HiDPI and non-HiDPI
    * displays, so that the ratio of points to device pixels changes.
    */
   NS_HIDDEN_(void) UIResolutionChanged();
   /*
    * Notify the pres context that a system color has changed
    */
   NS_HIDDEN_(void) SysColorChanged();
   /** Printing methods below should only be used for Medium() == print **/
   NS_HIDDEN_(void) SetPrintSettings(nsIPrintSettings *aPrintSettings);
   nsIPrintSettings* GetPrintSettings() { return mPrintSettings; }
   /* Accessor for table of frame properties */
   FramePropertyTable* PropertyTable() { return &mPropertyTable; }
   /* Helper function that ensures that this prescontext is shown in its
      docshell if it's the most recent prescontext for the docshell.  Returns
      whether the prescontext is now being shown.
   */
   NS_HIDDEN_(bool) EnsureVisible();
 #ifdef MOZ_REFLOW_PERF
   NS_HIDDEN_(void) CountReflows(const char * aName,
                                 nsIFrame * aFrame);
 #endif
   /**
    * This table maps border-width enums 'thin', 'medium', 'thick'
    * to actual nscoord values.
    */
   const nscoord* GetBorderWidthTable() { return mBorderWidthTable; }
   gfxTextPerfMetrics *GetTextPerfMetrics() { return mTextPerf; }
   bool IsDynamic() { return (mType == eContext_PageLayout || mType == eContext_Galley); }
   bool IsScreen() { return (mMedium == nsGkAtoms::screen ||
                               mType == eContext_PageLayout ||
                               mType == eContext_PrintPreview); }
   // Is this presentation in a chrome docshell?
   bool IsChrome() const { return mIsChrome; }
   bool IsChromeOriginImage() const { return mIsChromeOriginImage; }
   void UpdateIsChrome();
   // Public API for native theme code to get style internals.
   virtual bool HasAuthorSpecifiedRules(nsIFrame *aFrame, uint32_t ruleTypeMask) const;
   // Is it OK to let the page specify colors and backgrounds?
   bool UseDocumentColors() const {
     return GetCachedBoolPref(kPresContext_UseDocumentColors) || IsChrome() || IsChromeOriginImage();
   }
   // Explicitly enable and disable paint flashing.
   void SetPaintFlashing(bool aPaintFlashing) {
     mPaintFlashing = aPaintFlashing;
     mPaintFlashingInitialized = true;
   }
   // This method should be used instead of directly accessing mPaintFlashing,
   // as that value may be out of date when mPaintFlashingInitialized is false.
   bool GetPaintFlashing() const;
   bool             SupressingResizeReflow() const { return mSupressResizeReflow; }
   virtual NS_HIDDEN_(gfxUserFontSet*) GetUserFontSetExternal();
   NS_HIDDEN_(gfxUserFontSet*) GetUserFontSetInternal();
 #ifdef MOZILLA_INTERNAL_API
   gfxUserFontSet* GetUserFontSet() { return GetUserFontSetInternal(); }
 #else
   gfxUserFontSet* GetUserFontSet() { return GetUserFontSetExternal(); }
 #endif
   void FlushUserFontSet();
   void RebuildUserFontSet(); // asynchronously
   // Should be called whenever the set of fonts available in the user
   // font set changes (e.g., because a new font loads, or because the
   // user font set is changed and fonts become unavailable).
   void UserFontSetUpdated();
   // Ensure that it is safe to hand out CSS rules outside the layout
   // engine by ensuring that all CSS style sheets have unique inners
   // and, if necessary, synchronously rebuilding all style data.
   void EnsureSafeToHandOutCSSRules();
   void NotifyInvalidation(uint32_t aFlags);
   void NotifyInvalidation(const nsRect& aRect, uint32_t aFlags);
   // aRect is in device pixels
   void NotifyInvalidation(const nsIntRect& aRect, uint32_t aFlags);
   // aFlags are nsIPresShell::PAINT_ flags
   void NotifyDidPaintForSubtree(uint32_t aFlags);
   void FireDOMPaintEvent(nsInvalidateRequestList* aList);
   // Callback for catching invalidations in ContainerLayers
   // Passed to LayerProperties::ComputeDifference
   static void NotifySubDocInvalidation(mozilla::layers::ContainerLayer* aContainer,
                                        const nsIntRegion& aRegion);
   void SetNotifySubDocInvalidationData(mozilla::layers::ContainerLayer* aContainer);
   static void ClearNotifySubDocInvalidationData(mozilla::layers::ContainerLayer* aContainer);
   bool IsDOMPaintEventPending();
   void ClearMozAfterPaintEvents() {
     mInvalidateRequestsSinceLastPaint.mRequests.Clear();
     mUndeliveredInvalidateRequestsBeforeLastPaint.mRequests.Clear();
     mAllInvalidated = false;
   }
   bool IsProcessingRestyles() const {
     return mProcessingRestyles;
   }
   void SetProcessingRestyles(bool aProcessing) {
     NS_ASSERTION(aProcessing != bool(mProcessingRestyles),
                  "should never nest");
     mProcessingRestyles = aProcessing;
   }
   bool IsProcessingAnimationStyleChange() const {
     return mProcessingAnimationStyleChange;
   }
   void SetProcessingAnimationStyleChange(bool aProcessing) {
     NS_ASSERTION(aProcessing != bool(mProcessingAnimationStyleChange),
                  "should never nest");
     mProcessingAnimationStyleChange = aProcessing;
   }
   /**
    * Notify the prescontext that the presshell is about to reflow a reflow root.
    * The single argument indicates whether this reflow should be interruptible.
    * If aInterruptible is false then CheckForInterrupt and HasPendingInterrupt
    * will always return false. If aInterruptible is true then CheckForInterrupt
    * will return true when a pending event is detected.  This is for use by the
    * presshell only.  Reflow code wanting to prevent interrupts should use
    * InterruptPreventer.
    */
   void ReflowStarted(bool aInterruptible);
   /**
    * A class that can be used to temporarily disable reflow interruption.
    */
   class InterruptPreventer;
   friend class InterruptPreventer;
   class MOZ_STACK_CLASS InterruptPreventer {
   public:
     InterruptPreventer(nsPresContext* aCtx) :
       mCtx(aCtx),
       mInterruptsEnabled(aCtx->mInterruptsEnabled),
       mHasPendingInterrupt(aCtx->mHasPendingInterrupt)
     {
       mCtx->mInterruptsEnabled = false;
       mCtx->mHasPendingInterrupt = false;
     }
     ~InterruptPreventer() {
       mCtx->mInterruptsEnabled = mInterruptsEnabled;
       mCtx->mHasPendingInterrupt = mHasPendingInterrupt;
     }
   private:
     nsPresContext* mCtx;
     bool mInterruptsEnabled;
     bool mHasPendingInterrupt;
   };
   /**
    * Check for interrupts. This may return true if a pending event is
    * detected. Once it has returned true, it will keep returning true
    * until ReflowStarted is called. In all cases where this returns true,
    * the passed-in frame (which should be the frame whose reflow will be
    * interrupted if true is returned) will be passed to
    * nsIPresShell::FrameNeedsToContinueReflow.
    */
   bool CheckForInterrupt(nsIFrame* aFrame);
   /**
    * Returns true if CheckForInterrupt has returned true since the last
    * ReflowStarted call. Cannot itself trigger an interrupt check.
    */
   bool HasPendingInterrupt() { return mHasPendingInterrupt; }
   /**
    * If we have a presshell, and if the given content's current
    * document is the same as our presshell's document, return the
    * content's primary frame.  Otherwise, return null.  Only use this
    * if you care about which presshell the primary frame is in.
    */
   nsIFrame* GetPrimaryFrameFor(nsIContent* aContent);
   void NotifyDestroyingFrame(nsIFrame* aFrame)
   {
     PropertyTable()->DeleteAllFor(aFrame);
   }
   virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
   }
   bool IsRootContentDocument();
   bool IsCrossProcessRootContentDocument();
   bool IsGlyph() const {
     return mIsGlyph;
   }
   void SetIsGlyph(bool aValue) {
     mIsGlyph = aValue;
   }
   bool UsesRootEMUnits() const {
     return mUsesRootEMUnits;
   }
   void SetUsesRootEMUnits(bool aValue) {
     mUsesRootEMUnits = aValue;
   }
   bool UsesViewportUnits() const {
     return mUsesViewportUnits;
   }
   void SetUsesViewportUnits(bool aValue) {
     mUsesViewportUnits = aValue;
   }
   // true if there are OMTA transition updates for the current document which
   // have been throttled, and therefore some style information may not be up
   // to date
   bool ExistThrottledUpdates() const {
     return mExistThrottledUpdates;
   }
   void SetExistThrottledUpdates(bool aExistThrottledUpdates) {
     mExistThrottledUpdates = aExistThrottledUpdates;
   }
   bool IsDeviceSizePageSize();
   bool HasWarnedAboutPositionedTableParts() const {
     return mHasWarnedAboutPositionedTableParts;
   }
   void SetHasWarnedAboutPositionedTableParts() {
     mHasWarnedAboutPositionedTableParts = true;
   }
 protected:
   friend class nsRunnableMethod<nsPresContext>;
   NS_HIDDEN_(void) ThemeChangedInternal();
   NS_HIDDEN_(void) SysColorChangedInternal();
   NS_HIDDEN_(void) UIResolutionChangedInternal();
   static NS_HIDDEN_(bool)
   UIResolutionChangedSubdocumentCallback(nsIDocument* aDocument, void* aData);
   NS_HIDDEN_(void) SetImgAnimations(nsIContent *aParent, uint16_t aMode);
   NS_HIDDEN_(void) SetSMILAnimations(nsIDocument *aDoc, uint16_t aNewMode,
                                      uint16_t aOldMode);
   NS_HIDDEN_(void) GetDocumentColorPreferences();
   NS_HIDDEN_(void) PreferenceChanged(const char* aPrefName);
   static NS_HIDDEN_(void) PrefChangedCallback(const char*, void*);
   NS_HIDDEN_(void) UpdateAfterPreferencesChanged();
   static NS_HIDDEN_(void) PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
   NS_HIDDEN_(void) GetUserPreferences();
   // Allow nsAutoPtr<LangGroupFontPrefs> dtor to access this protected struct's
   // dtor:
   struct LangGroupFontPrefs;
   friend class nsAutoPtr<LangGroupFontPrefs>;
   struct LangGroupFontPrefs {
     // Font sizes default to zero; they will be set in GetFontPreferences
     LangGroupFontPrefs()
       : mLangGroup(nullptr)
       , mMinimumFontSize(0)
       , mDefaultVariableFont("serif", NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
                              NS_FONT_WEIGHT_NORMAL, NS_FONT_STRETCH_NORMAL, 0, 0)
       , mDefaultFixedFont("monospace", NS_FONT_STYLE_NORMAL,
                           NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
                           NS_FONT_STRETCH_NORMAL, 0, 0)
       , mDefaultSerifFont("serif", NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
                         NS_FONT_WEIGHT_NORMAL, NS_FONT_STRETCH_NORMAL, 0, 0)
       , mDefaultSansSerifFont("sans-serif", NS_FONT_STYLE_NORMAL,
                               NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
                               NS_FONT_STRETCH_NORMAL, 0, 0)
       , mDefaultMonospaceFont("monospace", NS_FONT_STYLE_NORMAL,
                               NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
                               NS_FONT_STRETCH_NORMAL, 0, 0)
       , mDefaultCursiveFont("cursive", NS_FONT_STYLE_NORMAL,
                             NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
                             NS_FONT_STRETCH_NORMAL, 0, 0)
       , mDefaultFantasyFont("fantasy", NS_FONT_STYLE_NORMAL,
                             NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
                             NS_FONT_STRETCH_NORMAL, 0, 0)
     {}
     size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
       size_t n = 0;
       LangGroupFontPrefs *curr = mNext;
       while (curr) {
         n += aMallocSizeOf(curr);
         // Measurement of the following members may be added later if DMD finds
         // it is worthwhile:
         // - mLangGroup
         // - mDefault*Font
         curr = curr->mNext;
       }
       return n;
     }
     nsCOMPtr<nsIAtom> mLangGroup;
     nscoord mMinimumFontSize;
     nsFont mDefaultVariableFont;
     nsFont mDefaultFixedFont;
     nsFont mDefaultSerifFont;
     nsFont mDefaultSansSerifFont;
     nsFont mDefaultMonospaceFont;
     nsFont mDefaultCursiveFont;
     nsFont mDefaultFantasyFont;
     nsAutoPtr<LangGroupFontPrefs> mNext;
   };
   /**
    * Fetch the user's font preferences for the given aLanguage's
    * langugage group.
    */
   const LangGroupFontPrefs* GetFontPrefsForLang(nsIAtom *aLanguage) const;
   void ResetCachedFontPrefs() {
     // Throw away any other LangGroupFontPrefs objects:
     mLangGroupFontPrefs.mNext = nullptr;
     // Make GetFontPreferences reinitialize mLangGroupFontPrefs:
     mLangGroupFontPrefs.mLangGroup = nullptr;
   }
   NS_HIDDEN_(void) UpdateCharSet(const nsCString& aCharSet);
 public:
   void DoChangeCharSet(const nsCString& aCharSet);
   /**
    * Checks for MozAfterPaint listeners on the document
    */
   bool MayHavePaintEventListener();
   /**
    * Checks for MozAfterPaint listeners on the document and
    * any subdocuments, except for subdocuments that are non-top-level
    * content documents.
    */
   bool MayHavePaintEventListenerInSubDocument();
 protected:
   void InvalidateThebesLayers();
   void AppUnitsPerDevPixelChanged();
   void HandleRebuildUserFontSet() {
     mPostedFlushUserFontSet = false;
     FlushUserFontSet();
   }
   bool HavePendingInputEvent();
   // Can't be inline because we can't include nsStyleSet.h.
   bool HasCachedStyleData();
   bool IsChromeSlow() const;
   // IMPORTANT: The ownership implicit in the following member variables
   // has been explicitly checked.  If you add any members to this class,
   // please make the ownership explicit (pinkerton, scc).
   nsPresContextType     mType;
   nsIPresShell*         mShell;         // [WEAK]
   nsCOMPtr<nsIDocument> mDocument;
   nsRefPtr<nsDeviceContext> mDeviceContext; // [STRONG] could be weak, but
                                             // better safe than sorry.
                                             // Cannot reintroduce cycles
                                             // since there is no dependency
                                             // from gfx back to layout.
   nsRefPtr<mozilla::EventStateManager> mEventManager;
   nsRefPtr<nsRefreshDriver> mRefreshDriver;
   nsRefPtr<nsTransitionManager> mTransitionManager;
   nsRefPtr<nsAnimationManager> mAnimationManager;
   nsRefPtr<mozilla::RestyleManager> mRestyleManager;
   nsIAtom*              mMedium;        // initialized by subclass ctors;
                                         // weak pointer to static atom
   nsCOMPtr<nsIAtom> mMediaEmulated;
   nsILinkHandler*       mLinkHandler;   // [WEAK]
   // Formerly mLangGroup; moving from charset-oriented langGroup to
   // maintaining actual language settings everywhere (see bug 524107).
   // This may in fact hold a langGroup such as x-western rather than
   // a specific language, however (e.g, if it is inferred from the
   // charset rather than explicitly specified as a lang attribute).
   nsCOMPtr<nsIAtom>     mLanguage;
 public:
   // The following are public member variables so that we can use them
   // with mozilla::AutoToggle or mozilla::AutoRestore.
   // Should we disable font size inflation because we're inside of
   // shrink-wrapping calculations on an inflation container?
   bool                  mInflationDisabledForShrinkWrap;
 protected:
   mozilla::WeakPtr<nsDocShell>             mContainer;
   PRCList               mDOMMediaQueryLists;
   // Base minimum font size, independent of the language-specific global preference. Defaults to 0
   int32_t               mBaseMinFontSize;
   float                 mTextZoom;      // Text zoom, defaults to 1.0
   float                 mFullZoom;      // Page zoom, defaults to 1.0
   float                 mLastFontInflationScreenWidth;
   int32_t               mCurAppUnitsPerDevPixel;
   int32_t               mAutoQualityMinFontSizePixelsPref;
   nsCOMPtr<nsITheme> mTheme;
   nsCOMPtr<nsILanguageAtomService> mLangService;
   nsCOMPtr<nsIPrintSettings> mPrintSettings;
   nsCOMPtr<nsITimer>    mPrefChangedTimer;
   FramePropertyTable    mPropertyTable;
   nsInvalidateRequestList mInvalidateRequestsSinceLastPaint;
   nsInvalidateRequestList mUndeliveredInvalidateRequestsBeforeLastPaint;
   // container for per-context fonts (downloadable, SVG, etc.)
   nsUserFontSet*        mUserFontSet;
   // text performance metrics
   nsAutoPtr<gfxTextPerfMetrics>   mTextPerf;
   nsRect                mVisibleArea;
   nsSize                mPageSize;
   float                 mPageScale;
   float                 mPPScale;
   nscolor               mDefaultColor;
   nscolor               mBackgroundColor;
   nscolor               mLinkColor;
   nscolor               mActiveLinkColor;
   nscolor               mVisitedLinkColor;
   nscolor               mFocusBackgroundColor;
   nscolor               mFocusTextColor;
   nscolor               mBodyTextColor;
   mozilla::ScrollbarStyles mViewportStyleOverflow;
   uint8_t               mFocusRingWidth;
   bool mExistThrottledUpdates;
   uint16_t              mImageAnimationMode;
   uint16_t              mImageAnimationModePref;
   LangGroupFontPrefs    mLangGroupFontPrefs;
   nscoord               mBorderWidthTable[3];
   uint32_t              mInterruptChecksToSkip;
   mozilla::TimeStamp    mReflowStartTime;
   PRInt32               mMaxFontAttempts;
   PRInt32               mMaxFonts;
   // last time animations styles were flushed to their primary frames
   mozilla::TimeStamp    mLastUpdateThrottledAnimationStyle;
   // last time transition styles were flushed to their primary frames
   mozilla::TimeStamp    mLastUpdateThrottledTransitionStyle;
   // last time we did a full style flush
   mozilla::TimeStamp    mLastStyleUpdateForAllAnimations;
   unsigned              mHasPendingInterrupt : 1;
   unsigned              mInterruptsEnabled : 1;
   unsigned              mUseDocumentFonts : 1;
   unsigned              mUseDocumentColors : 1;
   unsigned              mUnderlineLinks : 1;
   unsigned              mSendAfterPaintToContent : 1;
   unsigned              mUseFocusColors : 1;
   unsigned              mFocusRingOnAnything : 1;
   unsigned              mFocusRingStyle : 1;
   unsigned              mDrawImageBackground : 1;
   unsigned              mDrawColorBackground : 1;
   unsigned              mNeverAnimate : 1;
   unsigned              mIsRenderingOnlySelection : 1;
   unsigned              mPaginated : 1;
   unsigned              mCanPaginatedScroll : 1;
   unsigned              mDoScaledTwips : 1;
   unsigned              mIsRootPaginatedDocument : 1;
   unsigned              mPrefBidiDirection : 1;
   unsigned              mPrefScrollbarSide : 2;
   unsigned              mPendingSysColorChanged : 1;
   unsigned              mPendingThemeChanged : 1;
   unsigned              mPendingUIResolutionChanged : 1;
   unsigned              mPendingMediaFeatureValuesChanged : 1;
   unsigned              mPrefChangePendingNeedsReflow : 1;
   unsigned              mIsEmulatingMedia : 1;
   // True if the requests in mInvalidateRequestsSinceLastPaint cover the
   // entire viewport
   unsigned              mAllInvalidated : 1;
   // Are we currently drawing an SVG glyph?
   unsigned              mIsGlyph : 1;
   // Does the associated document use root-em (rem) units?
   unsigned              mUsesRootEMUnits : 1;
   // Does the associated document use viewport units (vw/vh/vmin/vmax)?
   unsigned              mUsesViewportUnits : 1;
   // Has there been a change to the viewport's dimensions?
   unsigned              mPendingViewportChange : 1;
   // Is the current mUserFontSet valid?
   unsigned              mUserFontSetDirty : 1;
   // Has GetUserFontSet() been called?
   unsigned              mGetUserFontSetCalled : 1;
   // Do we currently have an event posted to call FlushUserFontSet?
   unsigned              mPostedFlushUserFontSet : 1;
   // resize reflow is suppressed when the only change has been to zoom
   // the document rather than to change the document's dimensions
   unsigned              mSupressResizeReflow : 1;
   unsigned              mIsVisual : 1;
   unsigned              mProcessingRestyles : 1;
   unsigned              mProcessingAnimationStyleChange : 1;
   unsigned              mFireAfterPaintEvents : 1;
   unsigned              mIsChrome : 1;
   unsigned              mIsChromeOriginImage : 1;
   // Should we paint flash in this context? Do not use this variable directly.
   // Use GetPaintFlashing() method instead.
   mutable unsigned mPaintFlashing : 1;
   mutable unsigned mPaintFlashingInitialized : 1;
   unsigned mHasWarnedAboutPositionedTableParts : 1;
 #ifdef DEBUG
   bool                  mInitialized;
 #endif
 protected:
   virtual ~nsPresContext() NS_HIDDEN;
   // these are private, use the list in nsFont.h if you want a public list
   enum {
     eDefaultFont_Variable,
     eDefaultFont_Fixed,
     eDefaultFont_Serif,
     eDefaultFont_SansSerif,
     eDefaultFont_Monospace,
     eDefaultFont_Cursive,
     eDefaultFont_Fantasy,
     eDefaultFont_COUNT
   };
   nscolor MakeColorPref(const nsString& aColor);
   void LastRelease();
 #ifdef DEBUG
 private:
   friend struct nsAutoLayoutPhase;
   uint32_t mLayoutPhaseCount[eLayoutPhase_COUNT];
 public:
   uint32_t LayoutPhaseCount(nsLayoutPhase aPhase) {
     return mLayoutPhaseCount[aPhase];
   }
 #endif
 };
 class nsRootPresContext MOZ_FINAL : public nsPresContext {
 public:
   nsRootPresContext(nsIDocument* aDocument, nsPresContextType aType) NS_HIDDEN;
   virtual ~nsRootPresContext();
   virtual void Detach() MOZ_OVERRIDE;
   /**
    * Ensure that NotifyDidPaintForSubtree is eventually called on this
    * object after a timeout.
    */
   void EnsureEventualDidPaintEvent();
   void CancelDidPaintTimer()
   {
     if (mNotifyDidPaintTimer) {
       mNotifyDidPaintTimer->Cancel();
       mNotifyDidPaintTimer = nullptr;
     }
   }
   /**
    * Registers a plugin to receive geometry updates (position and clip
    * region) so it can update its widget.
    * Callers must call UnregisterPluginForGeometryUpdates before
    * the aPlugin frame is destroyed.
    */
   void RegisterPluginForGeometryUpdates(nsIContent* aPlugin);
   /**
    * Stops a plugin receiving geometry updates (position and clip
    * region). If the plugin was not already registered, this does
    * nothing.
    */
   void UnregisterPluginForGeometryUpdates(nsIContent* aPlugin);
   bool NeedToComputePluginGeometryUpdates()
   {
     return mRegisteredPlugins.Count() > 0;
   }
   /**
    * Compute geometry updates for each plugin given that aList is the display
    * list for aFrame. The updates are not yet applied;
    * ApplyPluginGeometryUpdates is responsible for that. In the meantime they
    * are stored on each nsObjectFrame.
    * This needs to be called even when aFrame is a popup, since although
    * windowed plugins aren't allowed in popups, windowless plugins are
    * and ComputePluginGeometryUpdates needs to be called for them.
    */
   void ComputePluginGeometryUpdates(nsIFrame* aFrame,
                                     nsDisplayListBuilder* aBuilder,
                                     nsDisplayList* aList);
   /**
    * Apply the stored plugin geometry updates. This should normally be called
    * in DidPaint so the plugins are moved/clipped immediately after we've
    * updated our window, so they look in sync with our window.
    */
   void ApplyPluginGeometryUpdates();
   virtual bool IsRoot() MOZ_OVERRIDE { return true; }
   /**
    * Increment DOM-modification generation counter to indicate that
    * the DOM has changed in a way that might lead to style changes/
    * reflows/frame creation and destruction.
    */
   void IncrementDOMGeneration() { mDOMGeneration++; }
   /**
    * Get the current DOM generation counter.
    *
    * See nsFrameManagerBase::GetGlobalGenerationNumber() for a
    * global generation number.
    */
   uint32_t GetDOMGeneration() { return mDOMGeneration; }
   /**
    * Add a runnable that will get called before the next paint. They will get
    * run eventually even if painting doesn't happen. They might run well before
    * painting happens.
    */
   void AddWillPaintObserver(nsIRunnable* aRunnable);
   /**
    * Run all runnables that need to get called before the next paint.
    */
   void FlushWillPaintObservers();
   virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
 protected:
   /**
    * Start a timer to ensure we eventually run ApplyPluginGeometryUpdates.
    */
   void InitApplyPluginGeometryTimer();
   /**
    * Cancel the timer that ensures we eventually run ApplyPluginGeometryUpdates.
    */
   void CancelApplyPluginGeometryTimer();
   class RunWillPaintObservers : public nsRunnable {
   public:
     RunWillPaintObservers(nsRootPresContext* aPresContext) : mPresContext(aPresContext) {}
     void Revoke() { mPresContext = nullptr; }
     NS_IMETHOD Run() MOZ_OVERRIDE
     {
       if (mPresContext) {
         mPresContext->FlushWillPaintObservers();
       }
       return NS_OK;
     }
     nsRootPresContext* mPresContext;
   };
   friend class nsPresContext;
   nsCOMPtr<nsITimer> mNotifyDidPaintTimer;
   nsCOMPtr<nsITimer> mApplyPluginGeometryTimer;
   nsTHashtable<nsRefPtrHashKey<nsIContent> > mRegisteredPlugins;
   nsTArray<nsCOMPtr<nsIRunnable> > mWillPaintObservers;
   nsRevocableEventPtr<RunWillPaintObservers> mWillPaintFallbackEvent;
   uint32_t mDOMGeneration;
 };
 #ifdef MOZ_REFLOW_PERF
 #define DO_GLOBAL_REFLOW_COUNT(_name) \
   aPresContext->CountReflows((_name), (nsIFrame*)this);
 #else
 #define DO_GLOBAL_REFLOW_COUNT(_name)
 #endif // MOZ_REFLOW_PERF
 #endif /* nsPresContext_h___ */

The Tor Browser / annotate

layout/base/nsPresContext.h@6474c204b198 (annotated)

layout/base/nsPresContext.h