The Tor Browser / file revision

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

 #ifndef nsLayoutUtils_h__

 #define nsLayoutUtils_h__

 #include "mozilla/MemoryReporting.h"

 #include "nsChangeHint.h"

 #include "nsAutoPtr.h"

 #include "nsFrameList.h"

 #include "mozilla/layout/FrameChildList.h"

 #include "nsThreadUtils.h"

 #include "nsIPrincipal.h"

 #include "GraphicsFilter.h"

 #include "nsCSSPseudoElements.h"

 #include "FrameMetrics.h"

 #include "gfx3DMatrix.h"

 #include "nsIWidget.h"

 #include "nsCSSProperty.h"

 #include "nsStyleCoord.h"

 #include "nsStyleConsts.h"

 #include "nsGkAtoms.h"

 #include "nsRuleNode.h"

 #include "imgIContainer.h"

 #include "mozilla/gfx/2D.h"

 #include "Units.h"

 #include <limits>

 #include <algorithm>

 class nsIFormControlFrame;

 class nsPresContext;

 class nsIContent;

 class nsIAtom;

 class nsIScrollableFrame;

 class nsIDOMEvent;

 class nsRegion;

 class nsDisplayListBuilder;

 class nsDisplayItem;

 class nsFontMetrics;

 class nsFontFaceList;

 class nsIImageLoadingContent;

 class nsStyleContext;

 class nsBlockFrame;

 class gfxASurface;

 class gfxDrawable;

 class nsView;

 class nsIFrame;

 class nsStyleCoord;

 class nsStyleCorners;

 class gfxContext;

 class nsPIDOMWindow;

 class imgIRequest;

 class nsIDocument;

 class gfxPoint;

 struct nsStyleFont;

 struct nsStyleImageOrientation;

 struct nsOverflowAreas;

 namespace mozilla {

 class SVGImageContext;

 struct IntrinsicSize;

 struct ContainerLayerParameters;

 namespace dom {

 class DOMRectList;

 class Element;

 class HTMLImageElement;

 class HTMLCanvasElement;

 class HTMLVideoElement;

 } // namespace dom

 namespace layers {

 class Layer;

 }

 }

 namespace mozilla {

 struct DisplayPortPropertyData {

   DisplayPortPropertyData(const nsRect& aRect, uint32_t aPriority)

     : mRect(aRect)

     , mPriority(aPriority)

   {}

   nsRect mRect;

   uint32_t mPriority;

 };

 struct DisplayPortMarginsPropertyData {

   DisplayPortMarginsPropertyData(const LayerMargin& aMargins,

                                  uint32_t aAlignmentX, uint32_t aAlignmentY,

                                  uint32_t aPriority)

     : mMargins(aMargins)

     , mAlignmentX(aAlignmentX)

     , mAlignmentY(aAlignmentY)

     , mPriority(aPriority)

   {}

   LayerMargin mMargins;

   uint32_t mAlignmentX;

   uint32_t mAlignmentY;

   uint32_t mPriority;

 };

 template <class AnimationsOrTransitions>

 extern AnimationsOrTransitions* HasAnimationOrTransition(nsIContent* aContent,

                                                          nsIAtom* aAnimationProperty,

                                                          nsCSSProperty aProperty);

 } // namespace mozilla

 /**

  * nsLayoutUtils is a namespace class used for various helper

  * functions that are useful in multiple places in layout.  The goal

  * is not to define multiple copies of the same static helper.

  */

 class nsLayoutUtils

 {

   typedef ::GraphicsFilter GraphicsFilter;

   typedef mozilla::dom::DOMRectList DOMRectList;

   typedef mozilla::layers::Layer Layer;

   typedef mozilla::ContainerLayerParameters ContainerLayerParameters;

   typedef mozilla::gfx::SourceSurface SourceSurface;

   typedef mozilla::gfx::DrawTarget DrawTarget;

   typedef mozilla::gfx::Rect Rect;

 public:

   typedef mozilla::layers::FrameMetrics FrameMetrics;

   typedef FrameMetrics::ViewID ViewID;

   typedef mozilla::CSSPoint CSSPoint;

   typedef mozilla::CSSSize CSSSize;

   typedef mozilla::LayerMargin LayerMargin;

   /**

    * Finds previously assigned ViewID for the given content element, if any.

    * Returns whether a ViewID was previously assigned.

    */

   static bool FindIDFor(const nsIContent* aContent, ViewID* aOutViewId);

   /**

    * Finds previously assigned or generates a unique ViewID for the given

    * content element.

    */

   static ViewID FindOrCreateIDFor(nsIContent* aContent);

   /**

    * Find content for given ID.

    */

   static nsIContent* FindContentFor(ViewID aId);

   /**

    * Find the scrollable frame for a given ID.

    */

   static nsIScrollableFrame* FindScrollableFrameFor(ViewID aId);

   /**

    * Get display port for the given element.

    */

   static bool GetDisplayPort(nsIContent* aContent, nsRect *aResult = nullptr);

   MOZ_BEGIN_NESTED_ENUM_CLASS(RepaintMode, uint8_t)

     Repaint,

     DoNotRepaint

   MOZ_END_NESTED_ENUM_CLASS(RepaintMode)

   /**

    * Set the display port margins for a content element to be used with a

    * display port base (see SetDisplayPortBase()).

    * See also nsIDOMWindowUtils.setDisplayPortMargins.

    * @param aContent the content element for which to set the margins

    * @param aPresShell the pres shell for the document containing the element

    * @param aMargins the margins to set

    * @param aAlignmentX, alignmentY the amount of pixels to which to align the

    *                                displayport built by combining the base

    *                                rect with the margins, in either direction

    * @param aPriority a priority value to determine which margins take effect

    *                  when multiple callers specify margins

    * @param aRepaintMode whether to schedule a paint after setting the margins

    */

   static void SetDisplayPortMargins(nsIContent* aContent,

                                     nsIPresShell* aPresShell,

                                     const LayerMargin& aMargins,

                                     uint32_t aAlignmentX,

                                     uint32_t aAlignmentY,

                                     uint32_t aPriority = 0,

                                     RepaintMode aRepaintMode = RepaintMode::Repaint);

   /**

    * Set the display port base rect for given element to be used with display

    * port margins.

    * SetDisplayPortBaseIfNotSet is like SetDisplayPortBase except it only sets

    * the display port base to aBase if no display port base is currently set.

    */

   static void SetDisplayPortBase(nsIContent* aContent, const nsRect& aBase);

   static void SetDisplayPortBaseIfNotSet(nsIContent* aContent, const nsRect& aBase);

   /**

    * Get the critical display port for the given element.

    */

   static bool GetCriticalDisplayPort(nsIContent* aContent, nsRect* aResult = nullptr);

   /**

    * Use heuristics to figure out the child list that

    * aChildFrame is currently in.

    */

   static mozilla::layout::FrameChildListID GetChildListNameFor(nsIFrame* aChildFrame);

   /**

    * GetBeforeFrame returns the outermost :before frame of the given frame, if

    * one exists.  This is typically O(1).  The frame passed in must be

    * the first-in-flow.

    *

    * @param aFrame the frame whose :before is wanted

    * @return the :before frame or nullptr if there isn't one

    */

   static nsIFrame* GetBeforeFrame(nsIFrame* aFrame);

   /**

    * GetAfterFrame returns the outermost :after frame of the given frame, if one

    * exists.  This will walk the in-flow chain to the last-in-flow if

    * needed.  This function is typically O(N) in the number of child

    * frames, following in-flows, etc.

    *

    * @param aFrame the frame whose :after is wanted

    * @return the :after frame or nullptr if there isn't one

    */

   static nsIFrame* GetAfterFrame(nsIFrame* aFrame);

   /**

    * Given a frame, search up the frame tree until we find an

    * ancestor that (or the frame itself) is of type aFrameType, if any.

    *

    * @param aFrame the frame to start at

    * @param aFrameType the frame type to look for

    * @return a frame of the given type or nullptr if no

    *         such ancestor exists

    */

   static nsIFrame* GetClosestFrameOfType(nsIFrame* aFrame, nsIAtom* aFrameType);

   /**

    * Given a frame, search up the frame tree until we find an

    * ancestor that (or the frame itself) is a "Page" frame, if any.

    *

    * @param aFrame the frame to start at

    * @return a frame of type nsGkAtoms::pageFrame or nullptr if no

    *         such ancestor exists

    */

   static nsIFrame* GetPageFrame(nsIFrame* aFrame)

   {

     return GetClosestFrameOfType(aFrame, nsGkAtoms::pageFrame);

   }

   /**

    * Given a frame which is the primary frame for an element,

    * return the frame that has the non-psuedoelement style context for

    * the content.

    * This is aPrimaryFrame itself except for tableOuter frames.

    */

   static nsIFrame* GetStyleFrame(nsIFrame* aPrimaryFrame);

   /**

    * Given a content node,

    * return the frame that has the non-psuedoelement style context for

    * the content.  May return null.

    * This is aContent->GetPrimaryFrame() except for tableOuter frames.

    */

   static nsIFrame* GetStyleFrame(const nsIContent* aContent);

   /**

    * IsGeneratedContentFor returns true if aFrame is the outermost

    * frame for generated content of type aPseudoElement for aContent.

    * aFrame *might not* have the aPseudoElement pseudo-style! For example

    * it might be a table outer frame and the inner table frame might

    * have the pseudo-style.

    *

    * @param aContent the content node we're looking at.  If this is

    *        null, then we just assume that aFrame has the right content

    *        pointer.

    * @param aFrame the frame we're looking at

    * @param aPseudoElement the pseudo type we're interested in

    * @return whether aFrame is the generated aPseudoElement frame for aContent

    */

   static bool IsGeneratedContentFor(nsIContent* aContent, nsIFrame* aFrame,

                                       nsIAtom* aPseudoElement);

 #ifdef DEBUG

   // TODO: remove, see bug 598468.

   static bool gPreventAssertInCompareTreePosition;

 #endif // DEBUG

   /**

    * CompareTreePosition determines whether aContent1 comes before or

    * after aContent2 in a preorder traversal of the content tree.

    *

    * @param aCommonAncestor either null, or a common ancestor of

    *                        aContent1 and aContent2.  Actually this is

    *                        only a hint; if it's not an ancestor of

    *                        aContent1 or aContent2, this function will

    *                        still work, but it will be slower than

    *                        normal.

    * @return < 0 if aContent1 is before aContent2

    *         > 0 if aContent1 is after aContent2,

    *         0 otherwise (meaning they're the same, or they're in

    *           different documents)

    */

   static int32_t CompareTreePosition(nsIContent* aContent1,

                                      nsIContent* aContent2,

                                      const nsIContent* aCommonAncestor = nullptr)

   {

     return DoCompareTreePosition(aContent1, aContent2, -1, 1, aCommonAncestor);

   }

   /*

    * More generic version of |CompareTreePosition|.  |aIf1Ancestor|

    * gives the value to return when 1 is an ancestor of 2, and likewise

    * for |aIf2Ancestor|.  Passing (-1, 1) gives preorder traversal

    * order, and (1, -1) gives postorder traversal order.

    */

   static int32_t DoCompareTreePosition(nsIContent* aContent1,

                                        nsIContent* aContent2,

                                        int32_t aIf1Ancestor,

                                        int32_t aIf2Ancestor,

                                        const nsIContent* aCommonAncestor = nullptr);

   /**

    * CompareTreePosition determines whether aFrame1 comes before or

    * after aFrame2 in a preorder traversal of the frame tree, where out

    * of flow frames are treated as children of their placeholders. This is

    * basically the same ordering as DoCompareTreePosition(nsIContent*) except

    * that it handles anonymous content properly and there are subtleties with

    * continuations.

    *

    * @param aCommonAncestor either null, or a common ancestor of

    *                        aContent1 and aContent2.  Actually this is

    *                        only a hint; if it's not an ancestor of

    *                        aContent1 or aContent2, this function will

    *                        still work, but it will be slower than

    *                        normal.

    * @return < 0 if aContent1 is before aContent2

    *         > 0 if aContent1 is after aContent2,

    *         0 otherwise (meaning they're the same, or they're in

    *           different frame trees)

    */

   static int32_t CompareTreePosition(nsIFrame* aFrame1,

                                      nsIFrame* aFrame2,

                                      nsIFrame* aCommonAncestor = nullptr)

   {

     return DoCompareTreePosition(aFrame1, aFrame2, -1, 1, aCommonAncestor);

   }

   static int32_t CompareTreePosition(nsIFrame* aFrame1,

                                      nsIFrame* aFrame2,

                                      nsTArray<nsIFrame*>& aFrame2Ancestors,

                                      nsIFrame* aCommonAncestor = nullptr)

   {

     return DoCompareTreePosition(aFrame1, aFrame2, aFrame2Ancestors,

                                  -1, 1, aCommonAncestor);

   }

   /*

    * More generic version of |CompareTreePosition|.  |aIf1Ancestor|

    * gives the value to return when 1 is an ancestor of 2, and likewise

    * for |aIf2Ancestor|.  Passing (-1, 1) gives preorder traversal

    * order, and (1, -1) gives postorder traversal order.

    */

   static int32_t DoCompareTreePosition(nsIFrame* aFrame1,

                                        nsIFrame* aFrame2,

                                        int32_t aIf1Ancestor,

                                        int32_t aIf2Ancestor,

                                        nsIFrame* aCommonAncestor = nullptr);

   static nsIFrame* FillAncestors(nsIFrame* aFrame,

                                  nsIFrame* aStopAtAncestor,

                                  nsTArray<nsIFrame*>* aAncestors);

   static int32_t DoCompareTreePosition(nsIFrame* aFrame1,

                                        nsIFrame* aFrame2,

                                        nsTArray<nsIFrame*>& aFrame2Ancestors,

                                        int32_t aIf1Ancestor,

                                        int32_t aIf2Ancestor,

                                        nsIFrame* aCommonAncestor);

   /**

    * LastContinuationWithChild gets the last continuation in aFrame's chain

    * that has a child, or the first continuation if the frame has no children.

    */

   static nsIFrame* LastContinuationWithChild(nsIFrame* aFrame);

   /**

    * GetLastSibling simply finds the last sibling of aFrame, or returns nullptr if

    * aFrame is null.

    */

   static nsIFrame* GetLastSibling(nsIFrame* aFrame);

   /**

    * FindSiblingViewFor locates the child of aParentView that aFrame's

    * view should be inserted 'above' (i.e., before in sibling view

    * order).  This is the first child view of aParentView whose

    * corresponding content is before aFrame's content (view siblings

    * are in reverse content order).

    */

   static nsView* FindSiblingViewFor(nsView* aParentView, nsIFrame* aFrame);

   /**

    * Get the parent of aFrame. If aFrame is the root frame for a document,

    * and the document has a parent document in the same view hierarchy, then

    * we try to return the subdocumentframe in the parent document.

    * @param aExtraOffset [in/out] if non-null, then as we cross documents

    * an extra offset may be required and it will be added to aCrossDocOffset.

    * Be careful dealing with this extra offset as it is in app units of the

    * parent document, which may have a different app units per dev pixel ratio

    * than the child document.

    */

   static nsIFrame* GetCrossDocParentFrame(const nsIFrame* aFrame,

                                           nsPoint* aCrossDocOffset = nullptr);

   /**

    * IsProperAncestorFrame checks whether aAncestorFrame is an ancestor

    * of aFrame and not equal to aFrame.

    * @param aCommonAncestor nullptr, or a common ancestor of aFrame and

    * aAncestorFrame. If non-null, this can bound the search and speed up

    * the function

    */

   static bool IsProperAncestorFrame(nsIFrame* aAncestorFrame, nsIFrame* aFrame,

                                       nsIFrame* aCommonAncestor = nullptr);

   /**

    * Like IsProperAncestorFrame, but looks across document boundaries.

    *

    * Just like IsAncestorFrameCrossDoc, except that it returns false when

    * aFrame == aAncestorFrame.

    */

   static bool IsProperAncestorFrameCrossDoc(nsIFrame* aAncestorFrame, nsIFrame* aFrame,

                                               nsIFrame* aCommonAncestor = nullptr);

   /**

    * IsAncestorFrameCrossDoc checks whether aAncestorFrame is an ancestor

    * of aFrame or equal to aFrame, looking across document boundaries.

    * @param aCommonAncestor nullptr, or a common ancestor of aFrame and

    * aAncestorFrame. If non-null, this can bound the search and speed up

    * the function.

    *

    * Just like IsProperAncestorFrameCrossDoc, except that it returns true when

    * aFrame == aAncestorFrame.

    */

   static bool IsAncestorFrameCrossDoc(const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,

                                         const nsIFrame* aCommonAncestor = nullptr);

   /**

    * Sets the fixed-pos metadata properties on aLayer.

    * aAnchorRect is the basic anchor rectangle. If aFixedPosFrame is not a viewport

    * frame, then we pick a corner of aAnchorRect to as the anchor point for the

    * fixed-pos layer (i.e. the point to remain stable during zooming), based

    * on which of the fixed-pos frame's CSS absolute positioning offset

    * properties (top, left, right, bottom) are auto. aAnchorRect is in the

    * coordinate space of aLayer's container layer (i.e. relative to the reference

    * frame of the display item which is building aLayer's container layer).

    */

   static void SetFixedPositionLayerData(Layer* aLayer, const nsIFrame* aViewportFrame,

                                         const nsRect& aAnchorRect,

                                         const nsIFrame* aFixedPosFrame,

                                         nsPresContext* aPresContext,

                                         const ContainerLayerParameters& aContainerParameters);

   /**

    * Return true if aPresContext's viewport has a displayport.

    * Fills in aDisplayPort with the displayport rectangle if non-null.

    */

   static bool ViewportHasDisplayPort(nsPresContext* aPresContext,

                                      nsRect* aDisplayPort = nullptr);

   /**

    * Return true if aFrame is a fixed-pos frame and is a child of a viewport

    * which has a displayport. These frames get special treatment from the compositor.

    * aDisplayPort, if non-null, is set to the display port rectangle (relative to

    * the viewport).

    */

   static bool IsFixedPosFrameInDisplayPort(const nsIFrame* aFrame,

                                            nsRect* aDisplayPort = nullptr);

   /**

    * Finds the nearest ancestor frame to aItem that is considered to have (or

    * will have) "animated geometry". For example the scrolled frames of

    * scrollframes which are actively being scrolled fall into this category.

    * Frames with certain CSS properties that are being animated (e.g.

    * 'left'/'top' etc) are also placed in this category.

    * Frames with different active geometry roots are in different ThebesLayers,

    * so that we can animate the geometry root by changing its transform (either

    * on the main thread or in the compositor).

    * The animated geometry root is required to be a descendant (or equal to)

    * aItem's ReferenceFrame(), which means that we will fall back to

    * returning aItem->ReferenceFrame() when we can't find another animated

    * geometry root.

    */

   static nsIFrame* GetAnimatedGeometryRootFor(nsDisplayItem* aItem,

                                               nsDisplayListBuilder* aBuilder);

   /**

     * GetScrollableFrameFor returns the scrollable frame for a scrolled frame

     */

   static nsIScrollableFrame* GetScrollableFrameFor(const nsIFrame *aScrolledFrame);

   /**

    * GetNearestScrollableFrameForDirection locates the first ancestor of

    * aFrame (or aFrame itself) that is scrollable with overflow:scroll or

    * overflow:auto in the given direction and where either the scrollbar for

    * that direction is visible or the frame can be scrolled by some

    * positive amount in that direction.

    * The search extends across document boundaries.

    *

    * @param  aFrame the frame to start with

    * @param  aDirection Whether it's for horizontal or vertical scrolling.

    * @return the nearest scrollable frame or nullptr if not found

    */

   enum Direction { eHorizontal, eVertical };

   static nsIScrollableFrame* GetNearestScrollableFrameForDirection(nsIFrame* aFrame,

                                                                    Direction aDirection);

   enum {

     SCROLLABLE_SAME_DOC = 0x01,

     SCROLLABLE_INCLUDE_HIDDEN = 0x02

   };

   /**

    * GetNearestScrollableFrame locates the first ancestor of aFrame

    * (or aFrame itself) that is scrollable with overflow:scroll or

    * overflow:auto in some direction.

    *

    * @param  aFrame the frame to start with

    * @param  aFlags if SCROLLABLE_SAME_DOC is set, do not search across

    * document boundaries. If SCROLLABLE_INCLUDE_HIDDEN is set, include

    * frames scrollable with overflow:hidden.

    * @return the nearest scrollable frame or nullptr if not found

    */

   static nsIScrollableFrame* GetNearestScrollableFrame(nsIFrame* aFrame,

                                                        uint32_t aFlags = 0);

   /**

    * GetScrolledRect returns the range of allowable scroll offsets

    * for aScrolledFrame, assuming the scrollable overflow area is

    * aScrolledFrameOverflowArea and the scrollport size is aScrollPortSize.

    * aDirection is either NS_STYLE_DIRECTION_LTR or NS_STYLE_DIRECTION_RTL.

    */

   static nsRect GetScrolledRect(nsIFrame* aScrolledFrame,

                                 const nsRect& aScrolledFrameOverflowArea,

                                 const nsSize& aScrollPortSize,

                                 uint8_t aDirection);

   /**

    * HasPseudoStyle returns true if aContent (whose primary style

    * context is aStyleContext) has the aPseudoElement pseudo-style

    * attached to it; returns false otherwise.

    *

    * @param aContent the content node we're looking at

    * @param aStyleContext aContent's style context

    * @param aPseudoElement the id of the pseudo style we care about

    * @param aPresContext the presentation context

    * @return whether aContent has aPseudoElement style attached to it

    */

   static bool HasPseudoStyle(nsIContent* aContent,

                                nsStyleContext* aStyleContext,

                                nsCSSPseudoElements::Type aPseudoElement,

                                nsPresContext* aPresContext);

   /**

    * If this frame is a placeholder for a float, then return the float,

    * otherwise return nullptr.  aPlaceholder must be a placeholder frame.

    */

   static nsIFrame* GetFloatFromPlaceholder(nsIFrame* aPlaceholder);

   // Combine aNewBreakType with aOrigBreakType, but limit the break types

   // to NS_STYLE_CLEAR_LEFT, RIGHT, LEFT_AND_RIGHT.

   static uint8_t CombineBreakType(uint8_t aOrigBreakType, uint8_t aNewBreakType);

   /**

    * Get the coordinates of a given DOM mouse event, relative to a given

    * frame. Works only for DOM events generated by WidgetGUIEvents.

    * @param aDOMEvent the event

    * @param aFrame the frame to make coordinates relative to

    * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if

    * for some reason the coordinates for the mouse are not known (e.g.,

    * the event is not a GUI event).

    */

   static nsPoint GetDOMEventCoordinatesRelativeTo(nsIDOMEvent* aDOMEvent,

                                                   nsIFrame* aFrame);

   /**

    * Get the coordinates of a given native mouse event, relative to a given

    * frame.

    * @param aEvent the event

    * @param aFrame the frame to make coordinates relative to

    * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if

    * for some reason the coordinates for the mouse are not known (e.g.,

    * the event is not a GUI event).

    */

   static nsPoint GetEventCoordinatesRelativeTo(

                    const mozilla::WidgetEvent* aEvent,

                    nsIFrame* aFrame);

   /**

    * Get the coordinates of a given point relative to an event and a

    * given frame.

    * @param aEvent the event

    * @param aPoint the point to get the coordinates relative to

    * @param aFrame the frame to make coordinates relative to

    * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if

    * for some reason the coordinates for the mouse are not known (e.g.,

    * the event is not a GUI event).

    */

   static nsPoint GetEventCoordinatesRelativeTo(

                    const mozilla::WidgetEvent* aEvent,

                    const nsIntPoint aPoint,

                    nsIFrame* aFrame);

   /**

    * Get the coordinates of a given point relative to a widget and a

    * given frame.

    * @param aWidget the event src widget

    * @param aPoint the point to get the coordinates relative to

    * @param aFrame the frame to make coordinates relative to

    * @return the point, or (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if

    * for some reason the coordinates for the mouse are not known (e.g.,

    * the event is not a GUI event).

    */

   static nsPoint GetEventCoordinatesRelativeTo(nsIWidget* aWidget,

                                                const nsIntPoint aPoint,

                                                nsIFrame* aFrame);

   /**

    * Get the popup frame of a given native mouse event.

    * @param aPresContext only check popups within aPresContext or a descendant

    * @param aEvent  the event.

    * @return        Null, if there is no popup frame at the point, otherwise,

    *                returns top-most popup frame at the point.

    */

   static nsIFrame* GetPopupFrameForEventCoordinates(

                      nsPresContext* aPresContext,

                      const mozilla::WidgetEvent* aEvent);

   /**

    * Translate from widget coordinates to the view's coordinates

    * @param aPresContext the PresContext for the view

    * @param aWidget the widget

    * @param aPt the point relative to the widget

    * @param aView  view to which returned coordinates are relative

    * @return the point in the view's coordinates

    */

   static nsPoint TranslateWidgetToView(nsPresContext* aPresContext,

                                        nsIWidget* aWidget, nsIntPoint aPt,

                                        nsView* aView);

   /**

    * Given a matrix and a point, let T be the transformation matrix translating points

    * in the coordinate space with origin aOrigin to the coordinate space used by the

    * matrix.  If M is the stored matrix, this function returns (T-1)MT, the matrix

    * that's equivalent to aMatrix but in the coordinate space that treats aOrigin

    * as the origin.

    *

    * @param aOrigin The origin to translate to.

    * @param aMatrix The matrix to change the basis of.

    * @return A matrix equivalent to aMatrix, but operating in the coordinate system with

    *         origin aOrigin.

    */

   static gfx3DMatrix ChangeMatrixBasis(const gfxPoint3D &aOrigin, const gfx3DMatrix &aMatrix);

   /**

    * Find IDs corresponding to a scrollable content element in the child process.

    * In correspondence with the shadow layer tree, you can use this to perform a

    * hit test that corresponds to a specific shadow layer that you can then perform

    * transformations on to do parent-side scrolling.

    *

    * @param aFrame The root frame of a stack context

    * @param aTarget The rect to hit test relative to the frame origin

    * @param aOutIDs All found IDs are added here

    * @param aIgnoreRootScrollFrame a boolean to control if the display list

    *        builder should ignore the root scroll frame

    */

   static nsresult GetRemoteContentIds(nsIFrame* aFrame,

                                      const nsRect& aTarget,

                                      nsTArray<ViewID> &aOutIDs,

                                      bool aIgnoreRootScrollFrame);

   enum FrameForPointFlags {

     /**

      * When set, paint suppression is ignored, so we'll return non-root page

      * elements even if paint suppression is stopping them from painting.

      */

     IGNORE_PAINT_SUPPRESSION = 0x01,

     /**

      * When set, clipping due to the root scroll frame (and any other viewport-

      * related clipping) is ignored.

      */

     IGNORE_ROOT_SCROLL_FRAME = 0x02,

     /**

      * When set, return only content in the same document as aFrame.

      */

     IGNORE_CROSS_DOC = 0x04

   };

   /**

    * Given aFrame, the root frame of a stacking context, find its descendant

    * frame under the point aPt that receives a mouse event at that location,

    * or nullptr if there is no such frame.

    * @param aPt the point, relative to the frame origin

    * @param aFlags some combination of FrameForPointFlags

    */

   static nsIFrame* GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt,

                                     uint32_t aFlags = 0);

   /**

    * Given aFrame, the root frame of a stacking context, find all descendant

    * frames under the area of a rectangle that receives a mouse event,

    * or nullptr if there is no such frame.

    * @param aRect the rect, relative to the frame origin

    * @param aOutFrames an array to add all the frames found

    * @param aFlags some combination of FrameForPointFlags

    */

   static nsresult GetFramesForArea(nsIFrame* aFrame, const nsRect& aRect,

                                    nsTArray<nsIFrame*> &aOutFrames,

                                    uint32_t aFlags = 0);

   /**

    * Transform aRect relative to aFrame up to the coordinate system of

    * aAncestor. Computes the bounding-box of the true quadrilateral.

    * Pass non-null aPreservesAxisAlignedRectangles and it will be set to true if

    * we only need to use a 2d transform that PreservesAxisAlignedRectangles().

    */

   static nsRect TransformFrameRectToAncestor(nsIFrame* aFrame,

                                              const nsRect& aRect,

                                              const nsIFrame* aAncestor,

                                              bool* aPreservesAxisAlignedRectangles = nullptr);

   /**

    * Gets the transform for aFrame relative to aAncestor. Pass null for aAncestor

    * to go up to the root frame.

    */

   static gfx3DMatrix GetTransformToAncestor(nsIFrame *aFrame, const nsIFrame *aAncestor);

   /**

    * Transforms a list of CSSPoints from aFromFrame to aToFrame, taking into

    * account all relevant transformations on the frames up to (but excluding)

    * their nearest common ancestor.

    * If we encounter a transform that we need to invert but which is

    * non-invertible, we return NONINVERTIBLE_TRANSFORM. If the frames have

    * no common ancestor, we return NO_COMMON_ANCESTOR.

    * If this returns TRANSFORM_SUCCEEDED, the points in aPoints are transformed

    * in-place, otherwise they are untouched.

    */

   enum TransformResult {

     TRANSFORM_SUCCEEDED,

     NO_COMMON_ANCESTOR,

     NONINVERTIBLE_TRANSFORM

   };

   static TransformResult TransformPoints(nsIFrame* aFromFrame, nsIFrame* aToFrame,

                                          uint32_t aPointCount, CSSPoint* aPoints);

   /**

    * Return true if a "layer transform" could be computed for aFrame,

    * and optionally return the computed transform.  The returned

    * transform is what would be set on the layer currently if a layers

    * transaction were opened at the time this helper is called.

    */

   static bool GetLayerTransformForFrame(nsIFrame* aFrame,

                                         gfx3DMatrix* aTransform);

   /**

    * Given a point in the global coordinate space, returns that point expressed

    * in the coordinate system of aFrame.  This effectively inverts all transforms

    * between this point and the root frame.

    *

    * @param aFrame The frame that acts as the coordinate space container.

    * @param aPoint The point, in the global space, to get in the frame-local space.

    * @return aPoint, expressed in aFrame's canonical coordinate space.

    */

   static nsPoint TransformRootPointToFrame(nsIFrame* aFrame,

                                            const nsPoint &aPoint)

   {

     return TransformAncestorPointToFrame(aFrame, aPoint, nullptr);

   }

   /**

    * Transform aPoint relative to aAncestor down to the coordinate system of

    * aFrame.

    */

   static nsPoint TransformAncestorPointToFrame(nsIFrame* aFrame,

                                                const nsPoint& aPoint,

                                                nsIFrame* aAncestor);

   /**

    * Helper function that, given a rectangle and a matrix, returns the smallest

    * rectangle containing the image of the source rectangle.

    *

    * @param aBounds The rectangle to transform.

    * @param aMatrix The matrix to transform it with.

    * @param aFactor The number of app units per graphics unit.

    * @return The smallest rect that contains the image of aBounds.

    */

   static nsRect MatrixTransformRect(const nsRect &aBounds,

                                     const gfx3DMatrix &aMatrix, float aFactor);

   /**

    * Helper function that, given a rectangle and a matrix, returns the smallest

    * rectangle containing the image of the source rectangle rounded out to the nearest

    * pixel value.

    *

    * @param aBounds The rectangle to transform.

    * @param aMatrix The matrix to transform it with.

    * @param aFactor The number of app units per graphics unit.

    * @return The smallest rect that contains the image of aBounds.

    */

   static nsRect MatrixTransformRectOut(const nsRect &aBounds,

                                     const gfx3DMatrix &aMatrix, float aFactor);

   /**

    * Helper function that, given a point and a matrix, returns the image

    * of that point under the matrix transform.

    *

    * @param aPoint The point to transform.

    * @param aMatrix The matrix to transform it with.

    * @param aFactor The number of app units per graphics unit.

    * @return The image of the point under the transform.

    */

   static nsPoint MatrixTransformPoint(const nsPoint &aPoint,

                                       const gfx3DMatrix &aMatrix, float aFactor);

   /**

    * Given a graphics rectangle in graphics space, return a rectangle in

    * app space that contains the graphics rectangle, rounding out as necessary.

    *

    * @param aRect The graphics rect to round outward.

    * @param aFactor The number of app units per graphics unit.

    * @return The smallest rectangle in app space that contains aRect.

    */

   static nsRect RoundGfxRectToAppRect(const Rect &aRect, float aFactor);

   /**

    * Given a graphics rectangle in graphics space, return a rectangle in

    * app space that contains the graphics rectangle, rounding out as necessary.

    *

    * @param aRect The graphics rect to round outward.

    * @param aFactor The number of app units per graphics unit.

    * @return The smallest rectangle in app space that contains aRect.

    */

   static nsRect RoundGfxRectToAppRect(const gfxRect &aRect, float aFactor);

   /**

    * Returns a subrectangle of aContainedRect that is entirely inside the rounded

    * rect. Complex cases are handled conservatively by returning a smaller

    * rect than necessary.

    */

   static nsRegion RoundedRectIntersectRect(const nsRect& aRoundedRect,

                                            const nscoord aRadii[8],

                                            const nsRect& aContainedRect);

   /**

    * Return whether any part of aTestRect is inside of the rounded

    * rectangle formed by aBounds and aRadii (which are indexed by the

    * NS_CORNER_* constants in nsStyleConsts.h). This is precise.

    */

   static bool RoundedRectIntersectsRect(const nsRect& aRoundedRect,

                                         const nscoord aRadii[8],

                                         const nsRect& aTestRect);

   enum {

     PAINT_IN_TRANSFORM = 0x01,

     PAINT_SYNC_DECODE_IMAGES = 0x02,

     PAINT_WIDGET_LAYERS = 0x04,

     PAINT_IGNORE_SUPPRESSION = 0x08,

     PAINT_DOCUMENT_RELATIVE = 0x10,

     PAINT_HIDE_CARET = 0x20,

     PAINT_ALL_CONTINUATIONS = 0x40,

     PAINT_TO_WINDOW = 0x80,

     PAINT_EXISTING_TRANSACTION = 0x100,

     PAINT_NO_COMPOSITE = 0x200,

     PAINT_COMPRESSED = 0x400

   };

   /**

    * Given aFrame, the root frame of a stacking context, paint it and its

    * descendants to aRenderingContext.

    * @param aRenderingContext a rendering context translated so that (0,0)

    * is the origin of aFrame; for best results, (0,0) should transform

    * to pixel-aligned coordinates. This can be null, in which case

    * aFrame must be a "display root" (root frame for a root document,

    * or the root of a popup) with an associated widget and we draw using

    * the layer manager for the frame's widget.

    * @param aDirtyRegion the region that must be painted, in the coordinates

    * of aFrame

    * @param aBackstop paint the dirty area with this color before drawing

    * the actual content; pass NS_RGBA(0,0,0,0) to draw no background

    * @param aFlags if PAINT_IN_TRANSFORM is set, then we assume

    * this is inside a transform or SVG foreignObject. If

    * PAINT_SYNC_DECODE_IMAGES is set, we force synchronous decode on all

    * images. If PAINT_WIDGET_LAYERS is set, aFrame must be a display root,

    * and we will use the frame's widget's layer manager to paint

    * even if aRenderingContext is non-null. This is useful if you want

    * to force rendering to use the widget's layer manager for testing

    * or speed. PAINT_WIDGET_LAYERS must be set if aRenderingContext is null.

    * If PAINT_DOCUMENT_RELATIVE is used, the visible region is interpreted

    * as being relative to the document.  (Normally it's relative to the CSS

    * viewport.) PAINT_TO_WINDOW sets painting to window to true on the display

    * list builder even if we can't tell that we are painting to the window.

    * If PAINT_EXISTING_TRANSACTION is set, then BeginTransaction() has already

    * been called on aFrame's widget's layer manager and should not be

    * called again.

    * If PAINT_COMPRESSED is set, the FrameLayerBuilder should be set to compressed mode

    * to avoid short cut optimizations.

    *

    * So there are three possible behaviours:

    * 1) PAINT_WIDGET_LAYERS is set and aRenderingContext is null; we paint

    * by calling BeginTransaction on the widget's layer manager

    * 2) PAINT_WIDGET_LAYERS is set and aRenderingContext is non-null; we

    * paint by calling BeginTransactionWithTarget on the widget's layer

    * maanger

    * 3) PAINT_WIDGET_LAYERS is not set and aRenderingContext is non-null;

    * we paint by construct a BasicLayerManager and calling

    * BeginTransactionWithTarget on it. This is desirable if we're doing

    * something like drawWindow in a mode where what gets rendered doesn't

    * necessarily correspond to what's visible in the window; we don't

    * want to mess up the widget's layer tree.

    */

   static nsresult PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,

                              const nsRegion& aDirtyRegion, nscolor aBackstop,

                              uint32_t aFlags = 0);

   /**

    * Uses a binary search for find where the cursor falls in the line of text

    * It also keeps track of the part of the string that has already been measured

    * so it doesn't have to keep measuring the same text over and over

    *

    * @param "aBaseWidth" contains the width in twips of the portion

    * of the text that has already been measured, and aBaseInx contains

    * the index of the text that has already been measured.

    *

    * @param aTextWidth returns the (in twips) the length of the text that falls

    * before the cursor aIndex contains the index of the text where the cursor falls

    */

   static bool

   BinarySearchForPosition(nsRenderingContext* acx,

                           const char16_t* aText,

                           int32_t    aBaseWidth,

                           int32_t    aBaseInx,

                           int32_t    aStartInx,

                           int32_t    aEndInx,

                           int32_t    aCursorPos,

                           int32_t&   aIndex,

                           int32_t&   aTextWidth);

   class BoxCallback {

   public:

     virtual void AddBox(nsIFrame* aFrame) = 0;

   };

   /**

    * Collect all CSS boxes associated with aFrame and its

    * continuations, "drilling down" through outer table frames and

    * some anonymous blocks since they're not real CSS boxes.

    * If aFrame is null, no boxes are returned.

    * SVG frames return a single box, themselves.

    */

   static void GetAllInFlowBoxes(nsIFrame* aFrame, BoxCallback* aCallback);

   /**

    * Find the first frame descendant of aFrame (including aFrame) which is

    * not an anonymous frame that getBoxQuads/getClientRects should ignore.

    */

   static nsIFrame* GetFirstNonAnonymousFrame(nsIFrame* aFrame);

   class RectCallback {

   public:

     virtual void AddRect(const nsRect& aRect) = 0;

   };

   struct RectAccumulator : public RectCallback {

     nsRect mResultRect;

     nsRect mFirstRect;

     bool mSeenFirstRect;

     RectAccumulator();

     virtual void AddRect(const nsRect& aRect);

   };

   struct RectListBuilder : public RectCallback {

     DOMRectList* mRectList;

     RectListBuilder(DOMRectList* aList);

     virtual void AddRect(const nsRect& aRect);

   };

   static nsIFrame* GetContainingBlockForClientRect(nsIFrame* aFrame);

   enum {

     RECTS_ACCOUNT_FOR_TRANSFORMS = 0x01,

     // Two bits for specifying which box type to use.

     // With neither bit set (default), use the border box.

     RECTS_USE_CONTENT_BOX = 0x02,

     RECTS_USE_PADDING_BOX = 0x04,

     RECTS_USE_MARGIN_BOX = 0x06, // both bits set

     RECTS_WHICH_BOX_MASK = 0x06 // bitmask for these two bits

   };

   /**

    * Collect all CSS boxes (content, padding, border, or margin) associated

    * with aFrame and its continuations, "drilling down" through outer table

    * frames and some anonymous blocks since they're not real CSS boxes.

    * The boxes are positioned relative to aRelativeTo (taking scrolling

    * into account) and passed to the callback in frame-tree order.

    * If aFrame is null, no boxes are returned.

    * For SVG frames, returns one rectangle, the bounding box.

    * If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting

    * the boxes into aRelativeTo coordinates, transforms (including CSS

    * and SVG transforms) are taken into account.

    * If aFlags includes one of RECTS_USE_CONTENT_BOX, RECTS_USE_PADDING_BOX,

    * or RECTS_USE_MARGIN_BOX, the corresponding type of box is used.

    * Otherwise (by default), the border box is used.

    */

   static void GetAllInFlowRects(nsIFrame* aFrame, nsIFrame* aRelativeTo,

                                 RectCallback* aCallback, uint32_t aFlags = 0);

   /**

    * Computes the union of all rects returned by GetAllInFlowRects. If

    * the union is empty, returns the first rect.

    * If aFlags includes RECTS_ACCOUNT_FOR_TRANSFORMS, then when converting

    * the boxes into aRelativeTo coordinates, transforms (including CSS

    * and SVG transforms) are taken into account.

    * If aFlags includes one of RECTS_USE_CONTENT_BOX, RECTS_USE_PADDING_BOX,

    * or RECTS_USE_MARGIN_BOX, the corresponding type of box is used.

    * Otherwise (by default), the border box is used.

    */

   static nsRect GetAllInFlowRectsUnion(nsIFrame* aFrame, nsIFrame* aRelativeTo,

                                        uint32_t aFlags = 0);

   enum {

     EXCLUDE_BLUR_SHADOWS = 0x01

   };

   /**

    * Takes a text-shadow array from the style properties of a given nsIFrame and

    * computes the union of those shadows along with the given initial rect.

    * If there are no shadows, the initial rect is returned.

    */

   static nsRect GetTextShadowRectsUnion(const nsRect& aTextAndDecorationsRect,

                                         nsIFrame* aFrame,

                                         uint32_t aFlags = 0);

   /**

    * Get the font metrics corresponding to the frame's style data.

    * @param aFrame the frame

    * @param aFontMetrics the font metrics result

    * @param aSizeInflation number to multiply font size by

    * @return success or failure code

    */

   static nsresult GetFontMetricsForFrame(const nsIFrame* aFrame,

                                          nsFontMetrics** aFontMetrics,

                                          float aSizeInflation = 1.0f);

   /**

    * Get the font metrics corresponding to the given style data.

    * @param aStyleContext the style data

    * @param aFontMetrics the font metrics result

    * @param aSizeInflation number to multiply font size by

    * @return success or failure code

    */

   static nsresult GetFontMetricsForStyleContext(nsStyleContext* aStyleContext,

                                                 nsFontMetrics** aFontMetrics,

                                                 float aSizeInflation = 1.0f);

   /**

    * Find the immediate child of aParent whose frame subtree contains

    * aDescendantFrame. Returns null if aDescendantFrame is not a descendant

    * of aParent.

    */

   static nsIFrame* FindChildContainingDescendant(nsIFrame* aParent, nsIFrame* aDescendantFrame);

   /**

    * Find the nearest ancestor that's a block

    */

   static nsBlockFrame* FindNearestBlockAncestor(nsIFrame* aFrame);

   /**

    * Find the nearest ancestor that's not for generated content. Will return

    * aFrame if aFrame is not for generated content.

    */

   static nsIFrame* GetNonGeneratedAncestor(nsIFrame* aFrame);

   /**

    * Cast aFrame to an nsBlockFrame* or return null if it's not

    * an nsBlockFrame.

    */

   static nsBlockFrame* GetAsBlock(nsIFrame* aFrame);

   /*

    * Whether the frame is an nsBlockFrame which is not a wrapper block.

    */

   static bool IsNonWrapperBlock(nsIFrame* aFrame);

   /**

    * If aFrame is an out of flow frame, return its placeholder, otherwise

    * return its parent.

    */

   static nsIFrame* GetParentOrPlaceholderFor(nsIFrame* aFrame);

   /**

    * If aFrame is an out of flow frame, return its placeholder, otherwise

    * return its (possibly cross-doc) parent.

    */

   static nsIFrame* GetParentOrPlaceholderForCrossDoc(nsIFrame* aFrame);

   /**

    * Get a frame's next-in-flow, or, if it doesn't have one, its

    * block-in-inline-split sibling.

    */

   static nsIFrame*

   GetNextContinuationOrIBSplitSibling(nsIFrame *aFrame);

   /**

    * Get the first frame in the continuation-plus-ib-split-sibling chain

    * containing aFrame.

    */

   static nsIFrame*

   FirstContinuationOrIBSplitSibling(nsIFrame *aFrame);

   /**

    * Is FirstContinuationOrIBSplitSibling(aFrame) going to return

    * aFrame?

    */

   static bool

   IsFirstContinuationOrIBSplitSibling(nsIFrame *aFrame);

   /**

    * Check whether aFrame is a part of the scrollbar or scrollcorner of

    * the root content.

    * @param aFrame the checking frame

    * @return if TRUE, the frame is a part of the scrollbar or scrollcorner of

    *         the root content.

    */

   static bool IsViewportScrollbarFrame(nsIFrame* aFrame);

   /**

    * Get the contribution of aFrame to its containing block's intrinsic

    * width.  This considers the child's intrinsic width, its 'width',

    * 'min-width', and 'max-width' properties, and its padding, border,

    * and margin.

    */

   enum IntrinsicWidthType { MIN_WIDTH, PREF_WIDTH };

   enum {

     IGNORE_PADDING = 0x01

   };

   static nscoord IntrinsicForContainer(nsRenderingContext* aRenderingContext,

                                        nsIFrame* aFrame,

                                        IntrinsicWidthType aType,

                                        uint32_t aFlags = 0);

   /*

    * Convert nsStyleCoord to nscoord when percentages depend on the

    * containing block size.

    * @param aPercentBasis The width or height of the containing block

    * (whichever the client wants to use for resolving percentages).

    */

   static nscoord ComputeCBDependentValue(nscoord aPercentBasis,

                                          const nsStyleCoord& aCoord);

   /*

    * Convert nsStyleCoord to nscoord when percentages depend on the

    * containing block width, and enumerated values are for width,

    * min-width, or max-width.  Returns the content-box width value based

    * on aContentEdgeToBoxSizing and aBoxSizingToMarginEdge (which are

    * also used for the enumerated values for width.  This function does

    * not handle 'auto'.  It ensures that the result is nonnegative.

    *

    * @param aRenderingContext Rendering context for font measurement/metrics.

    * @param aFrame Frame whose (min-/max-/)width is being computed

    * @param aContainingBlockWidth Width of aFrame's containing block.

    * @param aContentEdgeToBoxSizing The sum of any left/right padding and

    *          border that goes inside the rect chosen by box-sizing.

    * @param aBoxSizingToMarginEdge The sum of any left/right padding, border,

    *          and margin that goes outside the rect chosen by box-sizing.

    * @param aCoord The width value to compute.

    */

   static nscoord ComputeWidthValue(

                    nsRenderingContext* aRenderingContext,

                    nsIFrame*            aFrame,

                    nscoord              aContainingBlockWidth,

                    nscoord              aContentEdgeToBoxSizing,

                    nscoord              aBoxSizingToMarginEdge,

                    const nsStyleCoord&  aCoord);

   /*

    * Convert nsStyleCoord to nscoord when percentages depend on the

    * containing block height.

    */

   static nscoord ComputeHeightDependentValue(

                    nscoord              aContainingBlockHeight,

                    const nsStyleCoord&  aCoord);

   /*

    * Likewise, but for 'height', 'min-height', or 'max-height'.

    */

   static nscoord ComputeHeightValue(nscoord aContainingBlockHeight,

                                     nscoord aContentEdgeToBoxSizingBoxEdge,

                                     const nsStyleCoord& aCoord)

   {

     MOZ_ASSERT(aContainingBlockHeight != nscoord_MAX || !aCoord.HasPercent(),

                "caller must deal with %% of unconstrained height");

     MOZ_ASSERT(aCoord.IsCoordPercentCalcUnit());

     nscoord result =

       nsRuleNode::ComputeCoordPercentCalc(aCoord, aContainingBlockHeight);

     // Clamp calc(), and the subtraction for box-sizing.

     return std::max(0, result - aContentEdgeToBoxSizingBoxEdge);

   }

   static bool IsAutoHeight(const nsStyleCoord &aCoord, nscoord aCBHeight)

   {

     nsStyleUnit unit = aCoord.GetUnit();

     return unit == eStyleUnit_Auto ||  // only for 'height'

            unit == eStyleUnit_None ||  // only for 'max-height'

            (aCBHeight == nscoord_MAX && aCoord.HasPercent());

   }

   static bool IsPaddingZero(const nsStyleCoord &aCoord)

   {

     return (aCoord.GetUnit() == eStyleUnit_Coord &&

             aCoord.GetCoordValue() == 0) ||

            (aCoord.GetUnit() == eStyleUnit_Percent &&

             aCoord.GetPercentValue() == 0.0f) ||

            (aCoord.IsCalcUnit() &&

             // clamp negative calc() to 0

             nsRuleNode::ComputeCoordPercentCalc(aCoord, nscoord_MAX) <= 0 &&

             nsRuleNode::ComputeCoordPercentCalc(aCoord, 0) <= 0);

   }

   static bool IsMarginZero(const nsStyleCoord &aCoord)

   {

     return (aCoord.GetUnit() == eStyleUnit_Coord &&

             aCoord.GetCoordValue() == 0) ||

            (aCoord.GetUnit() == eStyleUnit_Percent &&

             aCoord.GetPercentValue() == 0.0f) ||

            (aCoord.IsCalcUnit() &&

             nsRuleNode::ComputeCoordPercentCalc(aCoord, nscoord_MAX) == 0 &&

             nsRuleNode::ComputeCoordPercentCalc(aCoord, 0) == 0);

   }

   static void MarkDescendantsDirty(nsIFrame *aSubtreeRoot);

   /*

    * Calculate the used values for 'width' and 'height' for a replaced element.

    *

    *   http://www.w3.org/TR/CSS21/visudet.html#min-max-widths

    */

   static nsSize ComputeSizeWithIntrinsicDimensions(

                     nsRenderingContext* aRenderingContext, nsIFrame* aFrame,

                     const mozilla::IntrinsicSize& aIntrinsicSize,

                     nsSize aIntrinsicRatio, nsSize aCBSize,

                     nsSize aMargin, nsSize aBorder, nsSize aPadding);

   /*

    * Calculate the used values for 'width' and 'height' when width

    * and height are 'auto'. The tentWidth and tentHeight arguments should be

    * the result of applying the rules for computing intrinsic sizes and ratios.

    * as specified by CSS 2.1 sections 10.3.2 and 10.6.2

    */

   static nsSize ComputeAutoSizeWithIntrinsicDimensions(nscoord minWidth, nscoord minHeight,

                                                        nscoord maxWidth, nscoord maxHeight,

                                                        nscoord tentWidth, nscoord tentHeight);

   // Implement nsIFrame::GetPrefWidth in terms of nsIFrame::AddInlinePrefWidth

   static nscoord PrefWidthFromInline(nsIFrame* aFrame,

                                      nsRenderingContext* aRenderingContext);

   // Implement nsIFrame::GetMinWidth in terms of nsIFrame::AddInlineMinWidth

   static nscoord MinWidthFromInline(nsIFrame* aFrame,

                                     nsRenderingContext* aRenderingContext);

   // Get a suitable foreground color for painting aProperty for aFrame.

   static nscolor GetColor(nsIFrame* aFrame, nsCSSProperty aProperty);

   // Get the native text color if appropriate.  If false is returned, callers

   // should fallback to the CSS color.

   static bool GetNativeTextColor(nsIFrame* aFrame, nscolor& aColor);

   // Get a baseline y position in app units that is snapped to device pixels.

   static gfxFloat GetSnappedBaselineY(nsIFrame* aFrame, gfxContext* aContext,

                                       nscoord aY, nscoord aAscent);

   static void DrawString(const nsIFrame*       aFrame,

                          nsRenderingContext*   aContext,

                          const char16_t*      aString,

                          int32_t               aLength,

                          nsPoint               aPoint,

                          nsStyleContext*       aStyleContext = nullptr);

   static nscoord GetStringWidth(const nsIFrame*      aFrame,

                                 nsRenderingContext* aContext,

                                 const char16_t*     aString,

                                 int32_t              aLength);

   /**

    * Helper function for drawing text-shadow. The callback's job

    * is to draw whatever needs to be blurred onto the given context.

    */

   typedef void (* TextShadowCallback)(nsRenderingContext* aCtx,

                                       nsPoint aShadowOffset,

                                       const nscolor& aShadowColor,

                                       void* aData);

   static void PaintTextShadow(const nsIFrame*     aFrame,

                               nsRenderingContext* aContext,

                               const nsRect&       aTextRect,

                               const nsRect&       aDirtyRect,

                               const nscolor&      aForegroundColor,

                               TextShadowCallback  aCallback,

                               void*               aCallbackData);

   /**

    * Gets the baseline to vertically center text from a font within a

    * line of specified height.

    *

    * Returns the baseline position relative to the top of the line.

    */

   static nscoord GetCenteredFontBaseline(nsFontMetrics* aFontMetrics,

                                          nscoord         aLineHeight);

   /**

    * Derive a baseline of |aFrame| (measured from its top border edge)

    * from its first in-flow line box (not descending into anything with

    * 'overflow' not 'visible', potentially including aFrame itself).

    *

    * Returns true if a baseline was found (and fills in aResult).

    * Otherwise returns false.

    */

   static bool GetFirstLineBaseline(const nsIFrame* aFrame, nscoord* aResult);

   /**

    * Just like GetFirstLineBaseline, except also returns the top and

    * bottom of the line with the baseline.

    *

    * Returns true if a line was found (and fills in aResult).

    * Otherwise returns false.

    */

   struct LinePosition {

     nscoord mTop, mBaseline, mBottom;

     LinePosition operator+(nscoord aOffset) const {

       LinePosition result;

       result.mTop = mTop + aOffset;

       result.mBaseline = mBaseline + aOffset;

       result.mBottom = mBottom + aOffset;

       return result;

     }

   };

   static bool GetFirstLinePosition(const nsIFrame* aFrame,

                                    LinePosition* aResult);

   /**

    * Derive a baseline of |aFrame| (measured from its top border edge)

    * from its last in-flow line box (not descending into anything with

    * 'overflow' not 'visible', potentially including aFrame itself).

    *

    * Returns true if a baseline was found (and fills in aResult).

    * Otherwise returns false.

    */

   static bool GetLastLineBaseline(const nsIFrame* aFrame, nscoord* aResult);

   /**

    * Returns a y coordinate relative to this frame's origin that represents

    * the logical bottom of the frame or its visible content, whichever is lower.

    * Relative positioning is ignored and margins and glyph bounds are not

    * considered.

    * This value will be >= mRect.height() and <= overflowRect.YMost() unless

    * relative positioning is applied.

    */

   static nscoord CalculateContentBottom(nsIFrame* aFrame);

   /**

    * Gets the closest frame (the frame passed in or one of its parents) that

    * qualifies as a "layer"; used in DOM0 methods that depends upon that

    * definition. This is the nearest frame that is either positioned or scrolled

    * (the child of a scroll frame).

    */

   static nsIFrame* GetClosestLayer(nsIFrame* aFrame);

   /**

    * Gets the graphics filter for the frame

    */

   static GraphicsFilter GetGraphicsFilterForFrame(nsIFrame* aFrame);

   /* N.B. The only difference between variants of the Draw*Image

    * functions below is the type of the aImage argument.

    */

   /**

    * Draw a background image.  The image's dimensions are as specified in aDest;

    * the image itself is not consulted to determine a size.

    * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering

    *   @param aRenderingContext Where to draw the image, set up with an

    *                            appropriate scale and transform for drawing in

    *                            app units.

    *   @param aImage            The image.

    *   @param aImageSize        The unscaled size of the image being drawn.

    *                            (This might be the image's size if no scaling

    *                            occurs, or it might be the image's size if

    *                            the image is a vector image being rendered at

    *                            that size.)

    *   @param aDest             The position and scaled area where one copy of

    *                            the image should be drawn.

    *   @param aFill             The area to be filled with copies of the

    *                            image.

    *   @param aAnchor           A point in aFill which we will ensure is

    *                            pixel-aligned in the output.

    *   @param aDirty            Pixels outside this area may be skipped.

    *   @param aImageFlags       Image flags of the imgIContainer::FLAG_* variety

    */

   static nsresult DrawBackgroundImage(nsRenderingContext* aRenderingContext,

                                       imgIContainer*      aImage,

                                       const nsIntSize&    aImageSize,

                                       GraphicsFilter      aGraphicsFilter,

                                       const nsRect&       aDest,

                                       const nsRect&       aFill,

                                       const nsPoint&      aAnchor,

                                       const nsRect&       aDirty,

                                       uint32_t            aImageFlags);

   /**

    * Draw an image.

    * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering

    *   @param aRenderingContext Where to draw the image, set up with an

    *                            appropriate scale and transform for drawing in

    *                            app units.

    *   @param aImage            The image.

    *   @param aDest             Where one copy of the image should mapped to.

    *   @param aFill             The area to be filled with copies of the

    *                            image.

    *   @param aAnchor           A point in aFill which we will ensure is

    *                            pixel-aligned in the output.

    *   @param aDirty            Pixels outside this area may be skipped.

    *   @param aImageFlags       Image flags of the imgIContainer::FLAG_* variety

    */

   static nsresult DrawImage(nsRenderingContext* aRenderingContext,

                             imgIContainer*       aImage,

                             GraphicsFilter       aGraphicsFilter,

                             const nsRect&        aDest,

                             const nsRect&        aFill,

                             const nsPoint&       aAnchor,

                             const nsRect&        aDirty,

                             uint32_t             aImageFlags);

   /**

    * Convert an nsRect to a gfxRect.

    */

   static gfxRect RectToGfxRect(const nsRect& aRect,

                                int32_t aAppUnitsPerDevPixel);

   /**

    * Draw a drawable using the pixel snapping algorithm.

    * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering

    *   @param aRenderingContext Where to draw the image, set up with an

    *                            appropriate scale and transform for drawing in

    *                            app units.

    *   @param aDrawable         The drawable we want to draw.

    *   @param aFilter           The graphics filter we should draw with.

    *   @param aDest             Where one copy of the image should mapped to.

    *   @param aFill             The area to be filled with copies of the

    *                            image.

    *   @param aAnchor           A point in aFill which we will ensure is

    *                            pixel-aligned in the output.

    *   @param aDirty            Pixels outside this area may be skipped.

    */

   static void DrawPixelSnapped(nsRenderingContext* aRenderingContext,

                                gfxDrawable*         aDrawable,

                                GraphicsFilter       aFilter,

                                const nsRect&        aDest,

                                const nsRect&        aFill,

                                const nsPoint&       aAnchor,

                                const nsRect&        aDirty);

   /**

    * Draw a whole image without scaling or tiling.

    *

    *   @param aRenderingContext Where to draw the image, set up with an

    *                            appropriate scale and transform for drawing in

    *                            app units.

    *   @param aImage            The image.

    *   @param aDest             The top-left where the image should be drawn

    *   @param aDirty            If non-null, then pixels outside this area may

    *                            be skipped.

    *   @param aImageFlags       Image flags of the imgIContainer::FLAG_* variety

    *   @param aSourceArea       If non-null, this area is extracted from

    *                            the image and drawn at aDest. It's

    *                            in appunits. For best results it should

    *                            be aligned with image pixels.

    */

   static nsresult DrawSingleUnscaledImage(nsRenderingContext* aRenderingContext,

                                           imgIContainer*       aImage,

                                           GraphicsFilter       aGraphicsFilter,

                                           const nsPoint&       aDest,

                                           const nsRect*        aDirty,

                                           uint32_t             aImageFlags,

                                           const nsRect*        aSourceArea = nullptr);

   /**

    * Draw a whole image without tiling.

    *

    *   @param aRenderingContext Where to draw the image, set up with an

    *                            appropriate scale and transform for drawing in

    *                            app units.

    *   @param aImage            The image.

    *   @param aDest             The area that the image should fill

    *   @param aDirty            Pixels outside this area may be skipped.

    *   @param aSVGContext       If non-null, SVG-related rendering context

    *                            such as overridden attributes on the image

    *                            document's root <svg> node. Ignored for

    *                            raster images.

    *   @param aImageFlags       Image flags of the imgIContainer::FLAG_*

    *                            variety.

    *   @param aSourceArea       If non-null, this area is extracted from

    *                            the image and drawn in aDest. It's

    *                            in appunits. For best results it should

    *                            be aligned with image pixels.

    */

   static nsresult DrawSingleImage(nsRenderingContext*    aRenderingContext,

                                   imgIContainer*         aImage,

                                   GraphicsFilter         aGraphicsFilter,

                                   const nsRect&          aDest,

                                   const nsRect&          aDirty,

                                   const mozilla::SVGImageContext* aSVGContext,

                                   uint32_t               aImageFlags,

                                   const nsRect*          aSourceArea = nullptr);

   /**

    * Given an imgIContainer, this method attempts to obtain an intrinsic

    * px-valued height & width for it.  If the imgIContainer has a non-pixel

    * value for either height or width, this method tries to generate a pixel

    * value for that dimension using the intrinsic ratio (if available).  The

    * intrinsic ratio will be assigned to aIntrinsicRatio; if there's no

    * intrinsic ratio then (0, 0) will be assigned.

    *

    * This method will always set aGotWidth and aGotHeight to indicate whether

    * we were able to successfully obtain (or compute) a value for each

    * dimension.

    *

    * NOTE: This method is similar to ComputeSizeWithIntrinsicDimensions.  The

    * difference is that this one is simpler and is suited to places where we

    * have less information about the frame tree.

    */

   static void ComputeSizeForDrawing(imgIContainer* aImage,

                                     nsIntSize&     aImageSize,

                                     nsSize&        aIntrinsicRatio,

                                     bool&          aGotWidth,

                                     bool&          aGotHeight);

   /**

    * Given a source area of an image (in appunits) and a destination area

    * that we want to map that source area too, computes the area that

    * would be covered by the whole image. This is useful for passing to

    * the aDest parameter of DrawImage, when we want to draw a subimage

    * of an overall image.

    */

   static nsRect GetWholeImageDestination(const nsIntSize& aWholeImageSize,

                                          const nsRect& aImageSourceArea,

                                          const nsRect& aDestArea);

   /**

    * Given an image container and an orientation, returns an image container

    * that contains the same image, reoriented appropriately. May return the

    * original image container if no changes are needed.

    *

    * @param aContainer   The image container to apply the orientation to.

    * @param aOrientation The desired orientation.

    */

   static already_AddRefed<imgIContainer>

   OrientImage(imgIContainer* aContainer,

               const nsStyleImageOrientation& aOrientation);

   /**

    * Determine if any corner radius is of nonzero size

    *   @param aCorners the |nsStyleCorners| object to check

    *   @return true unless all the coordinates are 0%, 0 or null.

    *

    * A corner radius with one dimension zero and one nonzero is

    * treated as a nonzero-radius corner, even though it will end up

    * being rendered like a zero-radius corner.  This is because such

    * corners are not expected to appear outside of test cases, and it's

    * simpler to implement the test this way.

    */

   static bool HasNonZeroCorner(const nsStyleCorners& aCorners);

   /**

    * Determine if there is any corner radius on corners adjacent to the

    * given side.

    */

   static bool HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,

                                        mozilla::css::Side aSide);

   /**

    * Determine if a widget is likely to require transparency or translucency.

    *   @param aBackgroundFrame The frame that the background is set on. For

    *                           <window>s, this will be the canvas frame.

    *   @param aCSSRootFrame    The frame that holds CSS properties affecting

    *                           the widget's transparency. For menupopups,

    *                           aBackgroundFrame and aCSSRootFrame will be the

    *                           same.

    *   @return a value suitable for passing to SetWindowTranslucency

    */

   static nsTransparencyMode GetFrameTransparency(nsIFrame* aBackgroundFrame,

                                                  nsIFrame* aCSSRootFrame);

   /**

    * A frame is a popup if it has its own floating window. Menus, panels

    * and combobox dropdowns are popups.

    */

   static bool IsPopup(nsIFrame* aFrame);

   /**

    * Find the nearest "display root". This is the nearest enclosing

    * popup frame or the root prescontext's root frame.

    */

   static nsIFrame* GetDisplayRootFrame(nsIFrame* aFrame);

   /**

    * Get the reference frame that would be used when constructing a

    * display item for this frame.  (Note, however, that

    * nsDisplayTransform use the reference frame appropriate for their

    * GetTransformRootFrame(), rather than using their own frame as a

    * reference frame.)

    *

    * This duplicates some of the logic of GetDisplayRootFrame above and

    * of nsDisplayListBuilder::FindReferenceFrameFor.

    *

    * If you have an nsDisplayListBuilder, you should get the reference

    * frame from it instead of calling this.

    */

   static nsIFrame* GetReferenceFrame(nsIFrame* aFrame);

   /**

    * Get the parent of this frame, except if that parent is part of a

    * preserve-3d hierarchy, get the parent of the root of the

    * preserve-3d hierarchy.

    *

    * (This is used as the starting point for reference frame computation

    * for nsDisplayTransform display items.)

    */

   static nsIFrame* GetTransformRootFrame(nsIFrame* aFrame);

   /**

    * Get textrun construction flags determined by a given style; in particular

    * some combination of:

    * -- TEXT_DISABLE_OPTIONAL_LIGATURES if letter-spacing is in use

    * -- TEXT_OPTIMIZE_SPEED if the text-rendering CSS property and font size

    * and prefs indicate we should be optimizing for speed over quality

    */

   static uint32_t GetTextRunFlagsForStyle(nsStyleContext* aStyleContext,

                                           const nsStyleFont* aStyleFont,

                                           const nsStyleText* aStyleText,

                                           nscoord aLetterSpacing);

   /**

    * Takes two rectangles whose origins must be the same, and computes

    * the difference between their union and their intersection as two

    * rectangles. (This difference is a superset of the difference

    * between the two rectangles.)

    */

   static void GetRectDifferenceStrips(const nsRect& aR1, const nsRect& aR2,

                                       nsRect* aHStrip, nsRect* aVStrip);

   /**

    * Get a device context that can be used to get up-to-date device

    * dimensions for the given window. For some reason, this is more

    * complicated than it ought to be in multi-monitor situations.

    */

   static nsDeviceContext*

   GetDeviceContextForScreenInfo(nsPIDOMWindow* aWindow);

   /**

    * Some frames with 'position: fixed' (nsStylePosition::mDisplay ==

    * NS_STYLE_POSITION_FIXED) are not really fixed positioned, since

    * they're inside an element with -moz-transform.  This function says

    * whether such an element is a real fixed-pos element.

    */

   static bool IsReallyFixedPos(nsIFrame* aFrame);

   /**

    * Obtain a gfxASurface from the given DOM element, if possible.

    * This obtains the most natural surface from the element; that

    * is, the one that can be obtained with the fewest conversions.

    *

    * The flags below can modify the behaviour of this function.  The

    * result is returned as a SurfaceFromElementResult struct, also

    * defined below.

    *

    * Currently, this will do:

    *  - HTML Canvas elements: will return the underlying canvas surface

    *  - HTML Video elements: will return the current video frame

    *  - Image elements: will return the image

    *

    * The above results are modified by the below flags (copying,

    * forcing image surface, etc.).

    */

   enum {

     /* When creating a new surface, create an image surface */

     SFE_WANT_IMAGE_SURFACE = 1 << 0,

     /* Whether to extract the first frame (as opposed to the

        current frame) in the case that the element is an image. */

     SFE_WANT_FIRST_FRAME = 1 << 1,

     /* Whether we should skip colorspace/gamma conversion */

     SFE_NO_COLORSPACE_CONVERSION = 1 << 2,

     /* Specifies that the caller wants unpremultiplied pixel data.

        If this is can be done efficiently, the result will be a

        DataSourceSurface and mIsPremultiplied with be set to false. */

     SFE_PREFER_NO_PREMULTIPLY_ALPHA = 1 << 3,

     /* Whether we should skip getting a surface for vector images and

        return a DirectDrawInfo containing an imgIContainer instead. */

     SFE_NO_RASTERIZING_VECTORS = 1 << 4

   };

   struct DirectDrawInfo {

     /* imgIContainer to directly draw to a context */

     nsCOMPtr<imgIContainer> mImgContainer;

     /* which frame to draw */

     uint32_t mWhichFrame;

     /* imgIContainer flags to use when drawing */

     uint32_t mDrawingFlags;

   };

   struct SurfaceFromElementResult {

     SurfaceFromElementResult();

     /* mSurface will contain the resulting surface, or will be nullptr on error */

     nsRefPtr<gfxASurface> mSurface;

     mozilla::RefPtr<SourceSurface> mSourceSurface;

     /* Contains info for drawing when there is no mSourceSurface. */

     DirectDrawInfo mDrawInfo;

     /* The size of the surface */

     gfxIntSize mSize;

     /* The principal associated with the element whose surface was returned.

        If there is a surface, this will never be null. */

     nsCOMPtr<nsIPrincipal> mPrincipal;

     /* The image request, if the element is an nsIImageLoadingContent */

     nsCOMPtr<imgIRequest> mImageRequest;

     /* Whether the element was "write only", that is, the bits should not be exposed to content */

     bool mIsWriteOnly;

     /* Whether the element was still loading.  Some consumers need to handle

        this case specially. */

     bool mIsStillLoading;

     /* Whether the element used CORS when loading. */

     bool mCORSUsed;

     /* Whether the returned image contains premultiplied pixel data */

     bool mIsPremultiplied;

   };

   static SurfaceFromElementResult SurfaceFromElement(mozilla::dom::Element *aElement,

                                                      uint32_t aSurfaceFlags = 0,

                                                      DrawTarget *aTarget = nullptr);

   static SurfaceFromElementResult SurfaceFromElement(nsIImageLoadingContent *aElement,

                                                      uint32_t aSurfaceFlags = 0,

                                                      DrawTarget *aTarget = nullptr);

   // Need an HTMLImageElement overload, because otherwise the

   // nsIImageLoadingContent and mozilla::dom::Element overloads are ambiguous

   // for HTMLImageElement.

   static SurfaceFromElementResult SurfaceFromElement(mozilla::dom::HTMLImageElement *aElement,

                                                      uint32_t aSurfaceFlags = 0,

                                                      DrawTarget *aTarget = nullptr);

   static SurfaceFromElementResult SurfaceFromElement(mozilla::dom::HTMLCanvasElement *aElement,

                                                      uint32_t aSurfaceFlags = 0,

                                                      DrawTarget *aTarget = nullptr);

   static SurfaceFromElementResult SurfaceFromElement(mozilla::dom::HTMLVideoElement *aElement,

                                                      uint32_t aSurfaceFlags = 0,

                                                      DrawTarget *aTarget = nullptr);

   /**

    * When the document is editable by contenteditable attribute of its root

    * content or body content.

    *

    * Be aware, this returns nullptr if it's in designMode.

    *

    * For example:

    *

    *  <html contenteditable="true"><body></body></html>

    *    returns the <html>.

    *

    *  <html><body contenteditable="true"></body></html>

    *  <body contenteditable="true"></body>

    *    With these cases, this returns the <body>.

    *    NOTE: The latter case isn't created normally, however, it can be

    *          created by script with XHTML.

    *

    *  <body><p contenteditable="true"></p></body>

    *    returns nullptr because <body> isn't editable.

    */

   static nsIContent*

     GetEditableRootContentByContentEditable(nsIDocument* aDocument);

   /**

    * Returns true if the passed in prescontext needs the dark grey background

    * that goes behind the page of a print preview presentation.

    */

   static bool NeedsPrintPreviewBackground(nsPresContext* aPresContext);

   /**

    * Adds all font faces used in the frame tree starting from aFrame

    * to the list aFontFaceList.

    */

   static nsresult GetFontFacesForFrames(nsIFrame* aFrame,

                                         nsFontFaceList* aFontFaceList);

   /**

    * Adds all font faces used within the specified range of text in aFrame,

    * and optionally its continuations, to the list in aFontFaceList.

    * Pass 0 and INT32_MAX for aStartOffset and aEndOffset to specify the

    * entire text is to be considered.

    */

   static nsresult GetFontFacesForText(nsIFrame* aFrame,

                                       int32_t aStartOffset,

                                       int32_t aEndOffset,

                                       bool aFollowContinuations,

                                       nsFontFaceList* aFontFaceList);

   /**

    * Walks the frame tree starting at aFrame looking for textRuns.

    * If |clear| is true, just clears the TEXT_RUN_MEMORY_ACCOUNTED flag

    * on each textRun found (and |aMallocSizeOf| is not used).

    * If |clear| is false, adds the storage used for each textRun to the

    * total, and sets the TEXT_RUN_MEMORY_ACCOUNTED flag to avoid double-

    * accounting. (Runs with this flag already set will be skipped.)

    * Expected usage pattern is therefore to call twice:

    *    (void)SizeOfTextRunsForFrames(rootFrame, nullptr, true);

    *    total = SizeOfTextRunsForFrames(rootFrame, mallocSizeOf, false);

    */

   static size_t SizeOfTextRunsForFrames(nsIFrame* aFrame,

                                         mozilla::MallocSizeOf aMallocSizeOf,

                                         bool clear);

   /**

    * Returns true if the content node has animations or transitions that can be

    * performed on the compositor.

    */

   static bool HasAnimationsForCompositor(nsIContent* aContent,

                                          nsCSSProperty aProperty);

   /**

    * Returns true if the content node has animations or transitions for the

    * property.

    */

   static bool HasAnimations(nsIContent* aContent, nsCSSProperty aProperty);

   /**

    * Checks if off-main-thread animations are enabled.

    */

   static bool AreAsyncAnimationsEnabled();

   /**

    * Checks if we should warn about animations that can't be async

    */

   static bool IsAnimationLoggingEnabled();

   /**

    * Find a suitable scale for an element (aContent) over the course of any

    * animations and transitions on the element.

    * It will check the maximum and minimum scale during the animations and

    * transitions and return a suitable value for performance and quality.

    * Will return scale(1,1) if there is no animated scaling.

    * Always return positive value.

    */

   static gfxSize ComputeSuitableScaleForAnimation(nsIContent* aContent);

   /**

    * Checks if we should forcibly use nearest pixel filtering for the

    * background.

    */

   static bool UseBackgroundNearestFiltering();

   /**

    * Checks whether we want to use the GPU to scale images when

    * possible.

    */

   static bool GPUImageScalingEnabled();

   /**

    * Checks whether we want to layerize animated images whenever possible.

    */

   static bool AnimatedImageLayersEnabled();

   /**

    * Checks if we should enable parsing for CSS Filters.

    */

   static bool CSSFiltersEnabled();

   /**

    * Checks whether support for the CSS-wide "unset" value is enabled.

    */

   static bool UnsetValueEnabled();

   /**

    * Checks whether support for the CSS text-align (and -moz-text-align-last)

    * 'true' value is enabled.

    */

   static bool IsTextAlignTrueValueEnabled();

   /**

    * Checks if CSS variables are currently enabled.

    */

   static bool CSSVariablesEnabled()

   {

     return sCSSVariablesEnabled;

   }

   static bool InterruptibleReflowEnabled()

   {

     return sInterruptibleReflowEnabled;

   }

   /**

    * Unions the overflow areas of the children of aFrame with aOverflowAreas.

    * aSkipChildLists specifies any child lists that should be skipped.

    * kSelectPopupList and kPopupList are always skipped.

    */

   static void UnionChildOverflow(nsIFrame* aFrame,

                                  nsOverflowAreas& aOverflowAreas,

                                  mozilla::layout::FrameChildListIDs aSkipChildLists =

                                      mozilla::layout::FrameChildListIDs());

   /**

    * Return the font size inflation *ratio* for a given frame.  This is

    * the factor by which font sizes should be inflated; it is never

    * smaller than 1.

    */

   static float FontSizeInflationFor(const nsIFrame *aFrame);

   /**

    * Perform the first half of the computation of FontSizeInflationFor

    * (see above).

    * This includes determining whether inflation should be performed

    * within this container and returning 0 if it should not be.

    *

    * The result is guaranteed not to vary between line participants

    * (inlines, text frames) within a line.

    *

    * The result should not be used directly since font sizes slightly

    * above the minimum should always be adjusted as done by

    * FontSizeInflationInner.

    */

   static nscoord InflationMinFontSizeFor(const nsIFrame *aFrame);

   /**

    * Perform the second half of the computation done by

    * FontSizeInflationFor (see above).

    *

    * aMinFontSize must be the result of one of the

    *   InflationMinFontSizeFor methods above.

    */

   static float FontSizeInflationInner(const nsIFrame *aFrame,

                                       nscoord aMinFontSize);

   static bool FontSizeInflationEnabled(nsPresContext *aPresContext);

   /**

    * See comment above "font.size.inflation.maxRatio" in

    * modules/libpref/src/init/all.js .

    */

   static uint32_t FontSizeInflationMaxRatio() {

     return sFontSizeInflationMaxRatio;

   }

   /**

    * See comment above "font.size.inflation.emPerLine" in

    * modules/libpref/src/init/all.js .

    */

   static uint32_t FontSizeInflationEmPerLine() {

     return sFontSizeInflationEmPerLine;

   }

   /**

    * See comment above "font.size.inflation.minTwips" in

    * modules/libpref/src/init/all.js .

    */

   static uint32_t FontSizeInflationMinTwips() {

     return sFontSizeInflationMinTwips;

   }

   /**

    * See comment above "font.size.inflation.lineThreshold" in

    * modules/libpref/src/init/all.js .

    */

   static uint32_t FontSizeInflationLineThreshold() {

     return sFontSizeInflationLineThreshold;

   }

   static bool FontSizeInflationForceEnabled() {

     return sFontSizeInflationForceEnabled;

   }

   static bool FontSizeInflationDisabledInMasterProcess() {

     return sFontSizeInflationDisabledInMasterProcess;

   }

   /**

    * See comment above "font.size.inflation.mappingIntercept" in

    * modules/libpref/src/init/all.js .

    */

   static int32_t FontSizeInflationMappingIntercept() {

     return sFontSizeInflationMappingIntercept;

   }

   /**

    * Returns true if the nglayout.debug.invalidation pref is set to true.

    * Note that sInvalidationDebuggingIsEnabled is declared outside this function to

    * allow it to be accessed an manipulated from breakpoint conditions.

    */

   static bool InvalidationDebuggingIsEnabled() {

     return sInvalidationDebuggingIsEnabled || getenv("MOZ_DUMP_INVALIDATION") != 0;

   }

   static void Initialize();

   static void Shutdown();

   /**

    * Register an imgIRequest object with a refresh driver.

    *

    * @param aPresContext The nsPresContext whose refresh driver we want to

    *        register with.

    * @param aRequest A pointer to the imgIRequest object which the client wants

    *        to register with the refresh driver.

    * @param aRequestRegistered A pointer to a boolean value which indicates

    *        whether the given image request is registered. If

    *        *aRequestRegistered is true, then this request will not be

    *        registered again. If the request is registered by this function,

    *        then *aRequestRegistered will be set to true upon the completion of

    *        this function.

    *

    */

   static void RegisterImageRequest(nsPresContext* aPresContext,

                                    imgIRequest* aRequest,

                                    bool* aRequestRegistered);

   /**

    * Register an imgIRequest object with a refresh driver, but only if the

    * request is for an image that is animated.

    *

    * @param aPresContext The nsPresContext whose refresh driver we want to

    *        register with.

    * @param aRequest A pointer to the imgIRequest object which the client wants

    *        to register with the refresh driver.

    * @param aRequestRegistered A pointer to a boolean value which indicates

    *        whether the given image request is registered. If

    *        *aRequestRegistered is true, then this request will not be

    *        registered again. If the request is registered by this function,

    *        then *aRequestRegistered will be set to true upon the completion of

    *        this function.

    *

    */

   static void RegisterImageRequestIfAnimated(nsPresContext* aPresContext,

                                              imgIRequest* aRequest,

                                              bool* aRequestRegistered);

   /**

    * Deregister an imgIRequest object from a refresh driver.

    *

    * @param aPresContext The nsPresContext whose refresh driver we want to

    *        deregister from.

    * @param aRequest A pointer to the imgIRequest object with which the client

    *        previously registered and now wants to deregister from the refresh

    *        driver.

    * @param aRequestRegistered A pointer to a boolean value which indicates

    *        whether the given image request is registered. If

    *        *aRequestRegistered is false, then this request will not be

    *        deregistered. If the request is deregistered by this function,

    *        then *aRequestRegistered will be set to false upon the completion of

    *        this function.

    */

   static void DeregisterImageRequest(nsPresContext* aPresContext,

                                      imgIRequest* aRequest,

                                      bool* aRequestRegistered);

   /**

    * Shim to nsCSSFrameConstructor::PostRestyleEvent. Exists so that we

    * can avoid including nsCSSFrameConstructor.h and all its dependencies

    * in content files.

    */

   static void PostRestyleEvent(mozilla::dom::Element* aElement,

                                nsRestyleHint aRestyleHint,

                                nsChangeHint aMinChangeHint);

   /**

    * Updates a pair of x and y distances if a given point is closer to a given

    * rectangle than the original distance values.  If aPoint is closer to

    * aRect than aClosestXDistance and aClosestYDistance indicate, then those

    * two variables are updated with the distance between aPoint and aRect,

    * and true is returned.  If aPoint is not closer, then aClosestXDistance

    * and aClosestYDistance are left unchanged, and false is returned.

    *

    * Distances are measured in the two dimensions separately; a closer x

    * distance beats a closer y distance.

    */

   template<typename PointType, typename RectType, typename CoordType>

   static bool PointIsCloserToRect(PointType aPoint, const RectType& aRect,

                                   CoordType& aClosestXDistance,

                                   CoordType& aClosestYDistance);

   /**

    * Computes the box shadow rect for the frame, or returns an empty rect if

    * there are no shadows.

    *

    * @param aFrame Frame to compute shadows for.

    * @param aFrameSize Size of aFrame (in case it hasn't been set yet).

    */

   static nsRect GetBoxShadowRectForFrame(nsIFrame* aFrame, const nsSize& aFrameSize);

 #ifdef DEBUG

   /**

    * Assert that there are no duplicate continuations of the same frame

    * within aFrameList.  Optimize the tests by assuming that all frames

    * in aFrameList have parent aContainer.

    */

   static void

   AssertNoDuplicateContinuations(nsIFrame* aContainer,

                                  const nsFrameList& aFrameList);

   /**

    * Assert that the frame tree rooted at |aSubtreeRoot| is empty, i.e.,

    * that it contains no first-in-flows.

    */

   static void

   AssertTreeOnlyEmptyNextInFlows(nsIFrame *aSubtreeRoot);

 #endif

   /**

    * Determine if aImageFrame (which is an nsImageFrame, nsImageControlFrame, or

    * nsSVGImageFrame) is visible or close to being visible via scrolling and

    * update the presshell with this knowledge.

    */

   static void

   UpdateImageVisibilityForFrame(nsIFrame* aImageFrame);

  /**

   * Calculate the compostion size for a frame. See FrameMetrics.h for

   * defintion of composition size (or bounds).

   */

   static nsSize

   CalculateCompositionSizeForFrame(nsIFrame* aFrame);

  /**

   * Calculate the composition size for the root scroll frame of the root

   * content document.

   * @param aFrame A frame in the root content document (or a descendant of it).

   * @param aIsRootContentDocRootScrollFrame Whether aFrame is already the root

   *          scroll frame of the root content document. In this case we just

   *          use aFrame's own composition size.

   * @param aMetrics A partially populated FrameMetrics for aFrame. Must have at

   *          least mCompositionBounds, mCumulativeResolution, and

   *          mDevPixelsPerCSSPixel set.

   */

   static CSSSize

   CalculateRootCompositionSize(nsIFrame* aFrame,

                                bool aIsRootContentDocRootScrollFrame,

                                const FrameMetrics& aMetrics);

  /**

   * Calculate the scrollable rect for a frame. See FrameMetrics.h for

   * defintion of scrollable rect. aScrollableFrame is the scroll frame to calculate

   * the scrollable rect for. If it's null then we calculate the scrollable rect

   * as the rect of the root frame.

   */

   static nsRect

   CalculateScrollableRectForFrame(nsIScrollableFrame* aScrollableFrame, nsIFrame* aRootFrame);

  /**

   * Calculate the expanded scrollable rect for a frame. See FrameMetrics.h for

   * defintion of expanded scrollable rect.

   */

   static nsRect

   CalculateExpandedScrollableRect(nsIFrame* aFrame);

   /**

    * Return whether we want to use APZ for subframes in this process.

    * Currently we don't support APZ for the parent process on B2G.

    */

   static bool WantSubAPZC();

  /**

    * Get the display port for |aScrollFrame|'s content. If |aScrollFrame|

    * WantsAsyncScroll() and we don't have a scrollable displayport yet (as

    * tracked by |aBuilder|), calculate and set a display port. Returns true if

    * there is (now) a displayport, and if so the displayport is returned in

    * |aOutDisplayport|.

    *

    * Note that a displayport can either be stored as a rect, or as a base

    * rect + margins. If it is stored as a base rect + margins, the base rect

    * is updated to |aDisplayPortBase|, and the rect assembled from the

    * base rect and margins is returned. If this function creates a displayport,

    * it computes margins and stores |aDisplayPortBase| as the base rect.

    *

    * This is intended to be called during display list building.

    */

   static bool GetOrMaybeCreateDisplayPort(nsDisplayListBuilder& aBuilder,

                                           nsIFrame* aScrollFrame,

                                           nsRect aDisplayPortBase,

                                           nsRect* aOutDisplayport);

 private:

   static uint32_t sFontSizeInflationEmPerLine;

   static uint32_t sFontSizeInflationMinTwips;

   static uint32_t sFontSizeInflationLineThreshold;

   static int32_t  sFontSizeInflationMappingIntercept;

   static uint32_t sFontSizeInflationMaxRatio;

   static bool sFontSizeInflationForceEnabled;

   static bool sFontSizeInflationDisabledInMasterProcess;

   static bool sInvalidationDebuggingIsEnabled;

   static bool sCSSVariablesEnabled;

   static bool sInterruptibleReflowEnabled;

 };

 MOZ_FINISH_NESTED_ENUM_CLASS(nsLayoutUtils::RepaintMode)

 template<typename PointType, typename RectType, typename CoordType>

 /* static */ bool

 nsLayoutUtils::PointIsCloserToRect(PointType aPoint, const RectType& aRect,

                                    CoordType& aClosestXDistance,

                                    CoordType& aClosestYDistance)

 {

   CoordType fromLeft = aPoint.x - aRect.x;

   CoordType fromRight = aPoint.x - aRect.XMost();

   CoordType xDistance;

   if (fromLeft >= 0 && fromRight <= 0) {

     xDistance = 0;

   } else {

     xDistance = std::min(abs(fromLeft), abs(fromRight));

   }

   if (xDistance <= aClosestXDistance) {

     if (xDistance < aClosestXDistance) {

       aClosestYDistance = std::numeric_limits<CoordType>::max();

     }

     CoordType fromTop = aPoint.y - aRect.y;

     CoordType fromBottom = aPoint.y - aRect.YMost();

     CoordType yDistance;

     if (fromTop >= 0 && fromBottom <= 0) {

       yDistance = 0;

     } else {

       yDistance = std::min(abs(fromTop), abs(fromBottom));

     }

     if (yDistance < aClosestYDistance) {

       aClosestXDistance = xDistance;

       aClosestYDistance = yDistance;

       return true;

     }

   }

   return false;

 }

 namespace mozilla {

   namespace layout {

     /**

      * An RAII class which will, for the duration of its lifetime,

      * **if** the frame given is a container for font size inflation,

      * set the current inflation container on the pres context to null

      * (and then, in its destructor, restore the old value).

      */

     class AutoMaybeDisableFontInflation {

     public:

       AutoMaybeDisableFontInflation(nsIFrame *aFrame);

       ~AutoMaybeDisableFontInflation();

     private:

       nsPresContext *mPresContext;

       bool mOldValue;

     };

   }

 }

 class nsSetAttrRunnable : public nsRunnable

 {

 public:

   nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,

                     const nsAString& aValue);

   nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,

                     int32_t aValue);

   NS_DECL_NSIRUNNABLE

   nsCOMPtr<nsIContent> mContent;

   nsCOMPtr<nsIAtom> mAttrName;

   nsAutoString mValue;

 };

 class nsUnsetAttrRunnable : public nsRunnable

 {

 public:

   nsUnsetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName);

   NS_DECL_NSIRUNNABLE

   nsCOMPtr<nsIContent> mContent;

   nsCOMPtr<nsIAtom> mAttrName;

 };

 #endif // nsLayoutUtils_h__