Add m-esr52 at 52.6.0

1 files changed, 920 insertions, 0 deletions

diff --git a/layout/generic/nsFrame.h b/layout/generic/nsFrame.h
new file mode 100644
index 000000000..f996f57d7
--- /dev/null
+++ b/layout/generic/nsFrame.h
@@ -0,0 +1,920 @@
+/* -*- 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/. */
+
+/* base class of all rendering objects */
+
+#ifndef nsFrame_h___
+#define nsFrame_h___
+
+#include "mozilla/Attributes.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/Likely.h"
+#include "nsBox.h"
+#include "mozilla/Logging.h"
+
+#include "nsIPresShell.h"
+#include "mozilla/ReflowInput.h"
+#include "nsHTMLParts.h"
+#include "nsISelectionDisplay.h"
+
+/**
+ * nsFrame logging constants. We redefine the nspr
+ * PRLogModuleInfo.level field to be a bitfield.  Each bit controls a
+ * specific type of logging. Each logging operation has associated
+ * inline methods defined below.
+ */
+#define NS_FRAME_TRACE_CALLS        0x1
+#define NS_FRAME_TRACE_PUSH_PULL    0x2
+#define NS_FRAME_TRACE_CHILD_REFLOW 0x4
+#define NS_FRAME_TRACE_NEW_FRAMES   0x8
+
+#define NS_FRAME_LOG_TEST(_lm,_bit) (int(((mozilla::LogModule*)_lm)->Level()) & (_bit))
+
+#ifdef DEBUG
+#define NS_FRAME_LOG(_bit,_args)                                \
+  PR_BEGIN_MACRO                                                \
+    if (NS_FRAME_LOG_TEST(nsFrame::sFrameLogModule,_bit)) {  \
+      PR_LogPrint _args;                                        \
+    }                                                           \
+  PR_END_MACRO
+#else
+#define NS_FRAME_LOG(_bit,_args)
+#endif
+
+// XXX Need to rework this so that logging is free when it's off
+#ifdef DEBUG
+#define NS_FRAME_TRACE_IN(_method) Trace(_method, true)
+
+#define NS_FRAME_TRACE_OUT(_method) Trace(_method, false)
+
+// XXX remove me
+#define NS_FRAME_TRACE_MSG(_bit,_args)                          \
+  PR_BEGIN_MACRO                                                \
+    if (NS_FRAME_LOG_TEST(nsFrame::sFrameLogModule,_bit)) {  \
+      TraceMsg _args;                                           \
+    }                                                           \
+  PR_END_MACRO
+
+#define NS_FRAME_TRACE(_bit,_args)                              \
+  PR_BEGIN_MACRO                                                \
+    if (NS_FRAME_LOG_TEST(nsFrame::sFrameLogModule,_bit)) {  \
+      TraceMsg _args;                                           \
+    }                                                           \
+  PR_END_MACRO
+
+#define NS_FRAME_TRACE_REFLOW_IN(_method) Trace(_method, true)
+
+#define NS_FRAME_TRACE_REFLOW_OUT(_method, _status) \
+  Trace(_method, false, _status)
+
+#else
+#define NS_FRAME_TRACE(_bits,_args)
+#define NS_FRAME_TRACE_IN(_method)
+#define NS_FRAME_TRACE_OUT(_method)
+#define NS_FRAME_TRACE_MSG(_bits,_args)
+#define NS_FRAME_TRACE_REFLOW_IN(_method)
+#define NS_FRAME_TRACE_REFLOW_OUT(_method, _status)
+#endif
+
+// Frame allocation boilerplate macros. Every subclass of nsFrame must
+// either use NS_{DECL,IMPL}_FRAMEARENA_HELPERS pair for allocating
+// memory correctly, or use NS_DECL_ABSTRACT_FRAME to declare a frame
+// class abstract and stop it from being instantiated. If a frame class
+// without its own operator new and GetFrameId gets instantiated, the
+// per-frame recycler lists in nsPresArena will not work correctly,
+// with potentially catastrophic consequences (not enough memory is
+// allocated for a frame object).
+
+#define NS_DECL_FRAMEARENA_HELPERS                                \
+  void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE;    \
+  virtual nsQueryFrame::FrameIID GetFrameId() override MOZ_MUST_OVERRIDE;
+
+#define NS_IMPL_FRAMEARENA_HELPERS(class)                         \
+  void* class::operator new(size_t sz, nsIPresShell* aShell)      \
+  { return aShell->AllocateFrame(nsQueryFrame::class##_id, sz); } \
+  nsQueryFrame::FrameIID class::GetFrameId()                      \
+  { return nsQueryFrame::class##_id; }
+
+#define NS_DECL_ABSTRACT_FRAME(class)                                   \
+  void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE = delete; \
+  virtual nsQueryFrame::FrameIID GetFrameId() override MOZ_MUST_OVERRIDE = 0;
+
+//----------------------------------------------------------------------
+
+struct nsBoxLayoutMetrics;
+struct nsRect;
+
+/**
+ * Implementation of a simple frame that's not splittable and has no
+ * child frames.
+ *
+ * Sets the NS_FRAME_SYNCHRONIZE_FRAME_AND_VIEW bit, so the default
+ * behavior is to keep the frame and view position and size in sync.
+ */
+class nsFrame : public nsBox
+{
+public:
+  /**
+   * Create a new "empty" frame that maps a given piece of content into a
+   * 0,0 area.
+   */
+  friend nsIFrame* NS_NewEmptyFrame(nsIPresShell* aShell,
+                                    nsStyleContext* aContext);
+
+private:
+  // Left undefined; nsFrame objects are never allocated from the heap.
+  void* operator new(size_t sz) CPP_THROW_NEW;
+
+protected:
+  // Overridden to prevent the global delete from being called, since
+  // the memory came out of an arena instead of the heap.
+  //
+  // Ideally this would be private and undefined, like the normal
+  // operator new.  Unfortunately, the C++ standard requires an
+  // overridden operator delete to be accessible to any subclass that
+  // defines a virtual destructor, so we can only make it protected;
+  // worse, some C++ compilers will synthesize calls to this function
+  // from the "deleting destructors" that they emit in case of
+  // delete-expressions, so it can't even be undefined.
+  void operator delete(void* aPtr, size_t sz);
+
+public:
+
+  // nsQueryFrame
+  NS_DECL_QUERYFRAME
+  void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE;
+  virtual nsQueryFrame::FrameIID GetFrameId() MOZ_MUST_OVERRIDE;
+
+  // nsIFrame
+  virtual void Init(nsIContent*       aContent,
+                    nsContainerFrame* aParent,
+                    nsIFrame*         aPrevInFlow) override;
+  virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
+  virtual nsStyleContext* GetAdditionalStyleContext(int32_t aIndex) const override;
+  virtual void SetAdditionalStyleContext(int32_t aIndex,
+                                         nsStyleContext* aStyleContext) override;
+  virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override;
+  virtual const nsFrameList& GetChildList(ChildListID aListID) const override;
+  virtual void GetChildLists(nsTArray<ChildList>* aLists) const override;
+
+  virtual nsresult  HandleEvent(nsPresContext* aPresContext, 
+                                mozilla::WidgetGUIEvent* aEvent,
+                                nsEventStatus* aEventStatus) override;
+  virtual nsresult  GetContentForEvent(mozilla::WidgetEvent* aEvent,
+                                       nsIContent** aContent) override;
+  virtual nsresult  GetCursor(const nsPoint&    aPoint,
+                              nsIFrame::Cursor& aCursor) override;
+
+  virtual nsresult  GetPointFromOffset(int32_t  inOffset,
+                                       nsPoint* outPoint) override;
+  virtual nsresult  GetCharacterRectsInRange(int32_t aInOffset,
+                                             int32_t aLength,
+                                             nsTArray<nsRect>& aOutRect) override;
+
+  virtual nsresult  GetChildFrameContainingOffset(int32_t    inContentOffset,
+                                                  bool       inHint,
+                                                  int32_t*   outFrameContentOffset,
+                                                  nsIFrame** outChildFrame) override;
+
+  static nsresult  GetNextPrevLineFromeBlockFrame(nsPresContext* aPresContext,
+                                        nsPeekOffsetStruct *aPos, 
+                                        nsIFrame *aBlockFrame, 
+                                        int32_t aLineStart, 
+                                        int8_t aOutSideLimit
+                                        );
+
+  virtual nsresult  CharacterDataChanged(CharacterDataChangeInfo* aInfo) override;
+  virtual nsresult  AttributeChanged(int32_t         aNameSpaceID,
+                                     nsIAtom*        aAttribute,
+                                     int32_t         aModType) override;
+  virtual nsSplittableType GetSplittableType() const override;
+  virtual nsIFrame* GetPrevContinuation() const override;
+  virtual void SetPrevContinuation(nsIFrame*) override;
+  virtual nsIFrame* GetNextContinuation() const override;
+  virtual void SetNextContinuation(nsIFrame*) override;
+  virtual nsIFrame* GetPrevInFlowVirtual() const override;
+  virtual void SetPrevInFlow(nsIFrame*) override;
+  virtual nsIFrame* GetNextInFlowVirtual() const override;
+  virtual void SetNextInFlow(nsIFrame*) override;
+  virtual nsIAtom* GetType() const override;
+
+  virtual nsresult IsSelectable(bool* aIsSelectable,
+                      mozilla::StyleUserSelect* aSelectStyle) const override;
+
+  virtual nsresult  GetSelectionController(nsPresContext *aPresContext, nsISelectionController **aSelCon) override;
+
+  virtual FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) override;
+  virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset,
+                                     bool aRespectClusters = true) override;
+  virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
+                                int32_t* aOffset, PeekWordState *aState) override;
+  /**
+   * Check whether we should break at a boundary between punctuation and
+   * non-punctuation. Only call it at a punctuation boundary
+   * (i.e. exactly one of the previous and next characters are punctuation).
+   * @param aForward true if we're moving forward in content order
+   * @param aPunctAfter true if the next character is punctuation
+   * @param aWhitespaceAfter true if the next character is whitespace
+   */
+  bool BreakWordBetweenPunctuation(const PeekWordState* aState,
+                                     bool aForward,
+                                     bool aPunctAfter, bool aWhitespaceAfter,
+                                     bool aIsKeyboardSelect);
+
+  virtual nsresult  CheckVisibility(nsPresContext* aContext, int32_t aStartIndex, int32_t aEndIndex, bool aRecurse, bool *aFinished, bool *_retval) override;
+
+  virtual nsresult  GetOffsets(int32_t &aStart, int32_t &aEnd) const override;
+  virtual void ChildIsDirty(nsIFrame* aChild) override;
+
+#ifdef ACCESSIBILITY
+  virtual mozilla::a11y::AccType AccessibleType() override;
+#endif
+
+  virtual nsStyleContext* GetParentStyleContext(nsIFrame** aProviderFrame) const override {
+    return DoGetParentStyleContext(aProviderFrame);
+  }
+
+  /**
+   * Do the work for getting the parent style context frame so that
+   * other frame's |GetParentStyleContext| methods can call this
+   * method on *another* frame.  (This function handles out-of-flow
+   * frames by using the frame manager's placeholder map and it also
+   * handles block-within-inline and generated content wrappers.)
+   *
+   * @param aProviderFrame (out) the frame associated with the returned value
+   *     or null if the style context is for display:contents content.
+   * @return The style context that should be the parent of this frame's
+   *         style context.  Null is permitted, and means that this frame's
+   *         style context should be the root of the style context tree.
+   */
+  nsStyleContext* DoGetParentStyleContext(nsIFrame** aProviderFrame) const;
+
+  virtual bool IsEmpty() override;
+  virtual bool IsSelfEmpty() override;
+
+  virtual void MarkIntrinsicISizesDirty() override;
+  virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
+  virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+  virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+                                 InlineMinISizeData *aData) override;
+  virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+                                  InlinePrefISizeData *aData) override;
+  virtual IntrinsicISizeOffsetData IntrinsicISizeOffsets() override;
+  virtual mozilla::IntrinsicSize GetIntrinsicSize() override;
+  virtual nsSize GetIntrinsicRatio() override;
+
+  virtual mozilla::LogicalSize
+  ComputeSize(nsRenderingContext*         aRenderingContext,
+              mozilla::WritingMode        aWM,
+              const mozilla::LogicalSize& aCBSize,
+              nscoord                     aAvailableISize,
+              const mozilla::LogicalSize& aMargin,
+              const mozilla::LogicalSize& aBorder,
+              const mozilla::LogicalSize& aPadding,
+              ComputeSizeFlags            aFlags) override;
+
+  /**
+   * Calculate the used values for 'width' and 'height' for a replaced element.
+   *   http://www.w3.org/TR/CSS21/visudet.html#min-max-widths
+   */
+  mozilla::LogicalSize
+  ComputeSizeWithIntrinsicDimensions(
+              nsRenderingContext*           aRenderingContext,
+              mozilla::WritingMode          aWM,
+              const mozilla::IntrinsicSize& aIntrinsicSize,
+              nsSize                        aIntrinsicRatio,
+              const mozilla::LogicalSize&   aCBSize,
+              const mozilla::LogicalSize&   aMargin,
+              const mozilla::LogicalSize&   aBorder,
+              const mozilla::LogicalSize&   aPadding,
+              ComputeSizeFlags              aFlags);
+
+  // Compute tight bounds assuming this frame honours its border, background
+  // and outline, its children's tight bounds, and nothing else.
+  nsRect ComputeSimpleTightBounds(mozilla::gfx::DrawTarget* aDrawTarget) const;
+  
+  /**
+   * A helper, used by |nsFrame::ComputeSize| (for frames that need to
+   * override only this part of ComputeSize), that computes the size
+   * that should be returned when 'width', 'height', and
+   * min/max-width/height are all 'auto' or equivalent.
+   *
+   * In general, frames that can accept any computed width/height should
+   * override only ComputeAutoSize, and frames that cannot do so need to
+   * override ComputeSize to enforce their width/height invariants.
+   *
+   * Implementations may optimize by returning a garbage width if
+   * StylePosition()->mWidth.GetUnit() != eStyleUnit_Auto, and
+   * likewise for height, since in such cases the result is guaranteed
+   * to be unused.
+   */
+  virtual mozilla::LogicalSize
+  ComputeAutoSize(nsRenderingContext*         aRenderingContext,
+                  mozilla::WritingMode        aWM,
+                  const mozilla::LogicalSize& aCBSize,
+                  nscoord                     aAvailableISize,
+                  const mozilla::LogicalSize& aMargin,
+                  const mozilla::LogicalSize& aBorder,
+                  const mozilla::LogicalSize& aPadding,
+                  ComputeSizeFlags            aFlags);
+
+  /**
+   * Utility function for ComputeAutoSize implementations.  Return
+   * max(GetMinISize(), min(aISizeInCB, GetPrefISize()))
+   */
+  nscoord ShrinkWidthToFit(nsRenderingContext* aRenderingContext,
+                           nscoord             aISizeInCB,
+                           ComputeSizeFlags    aFlags);
+
+  /**
+   * Calculates the size of this frame after reflowing (calling Reflow on, and
+   * updating the size and position of) its children, as necessary.  The
+   * calculated size is returned to the caller via the ReflowOutput
+   * outparam.  (The caller is responsible for setting the actual size and
+   * position of this frame.)
+   *
+   * A frame's children must _all_ be reflowed if the frame is dirty (the
+   * NS_FRAME_IS_DIRTY bit is set on it).  Otherwise, individual children
+   * must be reflowed if they are dirty or have the NS_FRAME_HAS_DIRTY_CHILDREN
+   * bit set on them.  Otherwise, whether children need to be reflowed depends
+   * on the frame's type (it's up to individual Reflow methods), and on what
+   * has changed.  For example, a change in the width of the frame may require
+   * all of its children to be reflowed (even those without dirty bits set on
+   * them), whereas a change in its height might not.
+   * (ReflowInput::ShouldReflowAllKids may be helpful in deciding whether
+   * to reflow all the children, but for some frame types it might result in
+   * over-reflow.)
+   *
+   * Note: if it's only the overflow rect(s) of a frame that need to be
+   * updated, then UpdateOverflow should be called instead of Reflow.
+   */
+  virtual void Reflow(nsPresContext*           aPresContext,
+                      ReflowOutput&     aDesiredSize,
+                      const ReflowInput& aReflowInput,
+                      nsReflowStatus&          aStatus) override;
+  virtual void DidReflow(nsPresContext*           aPresContext,
+                         const ReflowInput* aReflowInput,
+                         nsDidReflowStatus        aStatus) override;
+
+  /**
+   * NOTE: aStatus is assumed to be already-initialized. The reflow statuses of
+   * any reflowed absolute children will be merged into aStatus; aside from
+   * that, this method won't modify aStatus.
+   */
+  void ReflowAbsoluteFrames(nsPresContext*           aPresContext,
+                            ReflowOutput&     aDesiredSize,
+                            const ReflowInput& aReflowInput,
+                            nsReflowStatus&          aStatus,
+                            bool                     aConstrainBSize = true);
+  void FinishReflowWithAbsoluteFrames(nsPresContext*           aPresContext,
+                                      ReflowOutput&     aDesiredSize,
+                                      const ReflowInput& aReflowInput,
+                                      nsReflowStatus&          aStatus,
+                                      bool                     aConstrainBSize = true);
+
+  /*
+   * If this frame is dirty, marks all absolutely-positioned children of this
+   * frame dirty. If this frame isn't dirty, or if there are no
+   * absolutely-positioned children, does nothing.
+   *
+   * It's necessary to use PushDirtyBitToAbsoluteFrames() when you plan to
+   * reflow this frame's absolutely-positioned children after the dirty bit on
+   * this frame has already been cleared, which prevents ReflowInput from
+   * propagating the dirty bit normally. This situation generally only arises
+   * when a multipass layout algorithm is used.
+   */
+  void PushDirtyBitToAbsoluteFrames();
+
+  virtual bool CanContinueTextRun() const override;
+
+  virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override;
+
+  virtual void UnionChildOverflow(nsOverflowAreas& aOverflowAreas) override;
+
+  // Selection Methods
+
+  NS_IMETHOD HandlePress(nsPresContext* aPresContext,
+                         mozilla::WidgetGUIEvent* aEvent,
+                         nsEventStatus* aEventStatus);
+
+  NS_IMETHOD HandleMultiplePress(nsPresContext* aPresContext,
+                                 mozilla::WidgetGUIEvent* aEvent,
+                                 nsEventStatus* aEventStatus,
+                                 bool aControlHeld);
+
+  NS_IMETHOD HandleDrag(nsPresContext* aPresContext,
+                        mozilla::WidgetGUIEvent* aEvent,
+                        nsEventStatus* aEventStatus);
+
+  NS_IMETHOD HandleRelease(nsPresContext* aPresContext,
+                           mozilla::WidgetGUIEvent* aEvent,
+                           nsEventStatus* aEventStatus);
+
+  enum { SELECT_ACCUMULATE = 0x01 };
+
+  nsresult PeekBackwardAndForward(nsSelectionAmount aAmountBack,
+                                  nsSelectionAmount aAmountForward,
+                                  int32_t aStartPos,
+                                  bool aJumpLines,
+                                  uint32_t aSelectFlags);
+
+  nsresult SelectByTypeAtPoint(nsPresContext* aPresContext,
+                               const nsPoint& aPoint,
+                               nsSelectionAmount aBeginAmountType,
+                               nsSelectionAmount aEndAmountType,
+                               uint32_t aSelectFlags);
+
+  // Helper for GetContentAndOffsetsFromPoint; calculation of content offsets
+  // in this function assumes there is no child frame that can be targeted.
+  virtual ContentOffsets CalcContentOffsetsFromFramePoint(nsPoint aPoint);
+
+  // Box layout methods
+  virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
+  virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
+  virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+  virtual nscoord GetXULFlex() override;
+  virtual nscoord GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) override;
+
+  // We compute and store the HTML content's overflow area. So don't
+  // try to compute it in the box code.
+  virtual bool ComputesOwnOverflowArea() override { return true; }
+
+  //--------------------------------------------------
+  // Additional methods
+
+  // Helper function that tests if the frame tree is too deep; if it is
+  // it marks the frame as "unflowable", zeroes out the metrics, sets
+  // the reflow status, and returns true. Otherwise, the frame is
+  // unmarked "unflowable" and the metrics and reflow status are not
+  // touched and false is returned.
+  bool IsFrameTreeTooDeep(const ReflowInput& aReflowInput,
+                            ReflowOutput& aMetrics,
+                            nsReflowStatus& aStatus);
+
+  // Incorporate the child overflow areas into aOverflowAreas.
+  // If the child does not have a overflow, use the child area.
+  void ConsiderChildOverflow(nsOverflowAreas& aOverflowAreas,
+                             nsIFrame* aChildFrame);
+
+  /**
+   * @return true if we should avoid a page/column break in this frame.
+   */
+  bool ShouldAvoidBreakInside(const ReflowInput& aReflowInput) const {
+    return !aReflowInput.mFlags.mIsTopOfPage &&
+           NS_STYLE_PAGE_BREAK_AVOID == StyleDisplay()->mBreakInside &&
+           !GetPrevInFlow();
+  }
+
+#ifdef DEBUG
+  /**
+   * Tracing method that writes a method enter/exit routine to the
+   * nspr log using the nsIFrame log module. The tracing is only
+   * done when the NS_FRAME_TRACE_CALLS bit is set in the log module's
+   * level field.
+   */
+  void Trace(const char* aMethod, bool aEnter);
+  void Trace(const char* aMethod, bool aEnter, nsReflowStatus aStatus);
+  void TraceMsg(const char* fmt, ...);
+
+  // Helper function that verifies that each frame in the list has the
+  // NS_FRAME_IS_DIRTY bit set
+  static void VerifyDirtyBitSet(const nsFrameList& aFrameList);
+
+  static void XMLQuote(nsString& aString);
+
+  /**
+   * Dump out the "base classes" regression data. This should dump
+   * out the interior data, not the "frame" XML container. And it
+   * should call the base classes same named method before doing
+   * anything specific in a derived class. This means that derived
+   * classes need not override DumpRegressionData unless they need
+   * some custom behavior that requires changing how the outer "frame"
+   * XML container is dumped.
+   */
+  virtual void DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent);
+  
+  // Display Reflow Debugging 
+  static void* DisplayReflowEnter(nsPresContext*          aPresContext,
+                                  nsIFrame*                aFrame,
+                                  const ReflowInput& aReflowInput);
+  static void* DisplayLayoutEnter(nsIFrame* aFrame);
+  static void* DisplayIntrinsicISizeEnter(nsIFrame* aFrame,
+                                          const char* aType);
+  static void* DisplayIntrinsicSizeEnter(nsIFrame* aFrame,
+                                         const char* aType);
+  static void  DisplayReflowExit(nsPresContext*      aPresContext,
+                                 nsIFrame*            aFrame,
+                                 ReflowOutput& aMetrics,
+                                 uint32_t             aStatus,
+                                 void*                aFrameTreeNode);
+  static void  DisplayLayoutExit(nsIFrame* aFrame,
+                                 void* aFrameTreeNode);
+  static void  DisplayIntrinsicISizeExit(nsIFrame* aFrame,
+                                         const char* aType,
+                                         nscoord aResult,
+                                         void* aFrameTreeNode);
+  static void  DisplayIntrinsicSizeExit(nsIFrame* aFrame,
+                                        const char* aType,
+                                        nsSize aResult,
+                                        void* aFrameTreeNode);
+
+  static void DisplayReflowStartup();
+  static void DisplayReflowShutdown();
+#endif
+
+  /**
+   * Adds display items for standard CSS background if necessary.
+   * Does not check IsVisibleForPainting.
+   * @param aForceBackground draw the background even if the frame
+   * background style appears to have no background --- this is useful
+   * for frames that might receive a propagated background via
+   * nsCSSRendering::FindBackground
+   * @return whether a themed background item was created.
+   */
+  bool DisplayBackgroundUnconditional(nsDisplayListBuilder* aBuilder,
+                                      const nsDisplayListSet& aLists,
+                                      bool aForceBackground);
+  /**
+   * Adds display items for standard CSS borders, background and outline for
+   * for this frame, as necessary. Checks IsVisibleForPainting and won't
+   * display anything if the frame is not visible.
+   * @param aForceBackground draw the background even if the frame
+   * background style appears to have no background --- this is useful
+   * for frames that might receive a propagated background via
+   * nsCSSRendering::FindBackground
+   */
+  void DisplayBorderBackgroundOutline(nsDisplayListBuilder*   aBuilder,
+                                      const nsDisplayListSet& aLists,
+                                      bool aForceBackground = false);
+  /**
+   * Add a display item for the CSS outline. Does not check visibility.
+   */
+  void DisplayOutlineUnconditional(nsDisplayListBuilder*   aBuilder,
+                                   const nsDisplayListSet& aLists);
+  /**
+   * Add a display item for the CSS outline, after calling
+   * IsVisibleForPainting to confirm we are visible.
+   */
+  void DisplayOutline(nsDisplayListBuilder*   aBuilder,
+                      const nsDisplayListSet& aLists);
+
+  /**
+   * Adjust the given parent frame to the right style context parent frame for
+   * the child, given the pseudo-type of the prospective child.  This handles
+   * things like walking out of table pseudos and so forth.
+   *
+   * @param aProspectiveParent what GetParent() on the child returns.
+   *                           Must not be null.
+   * @param aChildPseudo the child's pseudo type, if any.
+   */
+  static nsIFrame*
+  CorrectStyleParentFrame(nsIFrame* aProspectiveParent, nsIAtom* aChildPseudo);
+
+protected:
+  // Protected constructor and destructor
+  explicit nsFrame(nsStyleContext* aContext);
+  virtual ~nsFrame();
+
+  /**
+   * To be called by |BuildDisplayLists| of this class or derived classes to add
+   * a translucent overlay if this frame's content is selected.
+   * @param aContentType an nsISelectionDisplay DISPLAY_ constant identifying
+   * which kind of content this is for
+   */
+  void DisplaySelectionOverlay(nsDisplayListBuilder* aBuilder,
+      nsDisplayList* aList, uint16_t aContentType = nsISelectionDisplay::DISPLAY_FRAMES);
+
+  int16_t DisplaySelection(nsPresContext* aPresContext, bool isOkToTurnOn = false);
+  
+  // Style post processing hook
+  virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
+
+public:
+  //given a frame five me the first/last leaf available
+  //XXX Robert O'Callahan wants to move these elsewhere
+  static void GetLastLeaf(nsPresContext* aPresContext, nsIFrame **aFrame);
+  static void GetFirstLeaf(nsPresContext* aPresContext, nsIFrame **aFrame);
+
+  // Return the line number of the aFrame, and (optionally) the containing block
+  // frame.
+  // If aScrollLock is true, don't break outside scrollframes when looking for a
+  // containing block frame.
+  static int32_t GetLineNumber(nsIFrame *aFrame,
+                               bool aLockScroll,
+                               nsIFrame** aContainingBlock = nullptr);
+
+  /**
+   * Returns true if aFrame should apply overflow clipping.
+   */
+  static bool ShouldApplyOverflowClipping(const nsIFrame* aFrame,
+                                          const nsStyleDisplay* aDisp)
+  {
+    // clip overflow:-moz-hidden-unscrollable, except for nsListControlFrame,
+    // which is an nsHTMLScrollFrame.
+    if (MOZ_UNLIKELY(aDisp->mOverflowX == NS_STYLE_OVERFLOW_CLIP &&
+                     aFrame->GetType() != nsGkAtoms::listControlFrame)) {
+      return true;
+    }
+
+    // and overflow:hidden that we should interpret as -moz-hidden-unscrollable
+    if (aDisp->mOverflowX == NS_STYLE_OVERFLOW_HIDDEN &&
+        aDisp->mOverflowY == NS_STYLE_OVERFLOW_HIDDEN) {
+      // REVIEW: these are the frame types that set up clipping.
+      nsIAtom* type = aFrame->GetType();
+      if (type == nsGkAtoms::tableFrame ||
+          type == nsGkAtoms::tableCellFrame ||
+          type == nsGkAtoms::bcTableCellFrame ||
+          type == nsGkAtoms::svgOuterSVGFrame ||
+          type == nsGkAtoms::svgInnerSVGFrame ||
+          type == nsGkAtoms::svgForeignObjectFrame) {
+        return true;
+      }
+      if (aFrame->IsFrameOfType(nsIFrame::eReplacedContainsBlock)) {
+        if (type == nsGkAtoms::textInputFrame) {
+          // It always has an anonymous scroll frame that handles any overflow.
+          return false;
+        }
+        return true;
+      }
+    }
+
+    if ((aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT)) {
+      return false;
+    }
+
+    // If we're paginated and a block, and have NS_BLOCK_CLIP_PAGINATED_OVERFLOW
+    // set, then we want to clip our overflow.
+    return
+      (aFrame->GetStateBits() & NS_BLOCK_CLIP_PAGINATED_OVERFLOW) != 0 &&
+      aFrame->PresContext()->IsPaginated() &&
+      aFrame->GetType() == nsGkAtoms::blockFrame;
+  }
+
+  virtual nsILineIterator* GetLineIterator() override;
+
+protected:
+
+  // Test if we are selecting a table object:
+  //  Most table/cell selection requires that Ctrl (Cmd on Mac) key is down 
+  //   during a mouse click or drag. Exception is using Shift+click when
+  //   already in "table/cell selection mode" to extend a block selection
+  //  Get the parent content node and offset of the frame 
+  //   of the enclosing cell or table (if not inside a cell)
+  //  aTarget tells us what table element to select (currently only cell and table supported)
+  //  (enums for this are defined in nsIFrame.h)
+  NS_IMETHOD GetDataForTableSelection(const nsFrameSelection* aFrameSelection,
+                                      nsIPresShell* aPresShell,
+                                      mozilla::WidgetMouseEvent* aMouseEvent,
+                                      nsIContent** aParentContent,
+                                      int32_t* aContentOffset,
+                                      int32_t* aTarget);
+
+  // Fills aCursor with the appropriate information from ui
+  static void FillCursorInformationFromStyle(const nsStyleUserInterface* ui,
+                                             nsIFrame::Cursor& aCursor);
+  NS_IMETHOD DoXULLayout(nsBoxLayoutState& aBoxLayoutState) override;
+
+#ifdef DEBUG_LAYOUT
+  virtual void GetBoxName(nsAutoString& aName) override;
+#endif
+
+  nsBoxLayoutMetrics* BoxMetrics() const;
+
+  // Fire DOM event. If no aContent argument use frame's mContent.
+  void FireDOMEvent(const nsAString& aDOMEventName, nsIContent *aContent = nullptr);
+
+private:
+  void BoxReflow(nsBoxLayoutState& aState,
+                 nsPresContext*    aPresContext,
+                 ReflowOutput&     aDesiredSize,
+                 nsRenderingContext* aRenderingContext,
+                 nscoord aX,
+                 nscoord aY,
+                 nscoord aWidth,
+                 nscoord aHeight,
+                 bool aMoveFrame = true);
+
+  NS_IMETHODIMP RefreshSizeCache(nsBoxLayoutState& aState);
+
+  // Returns true if this frame has any kind of CSS animations.
+  bool HasCSSAnimations();
+
+  // Returns true if this frame has any kind of CSS transitions.
+  bool HasCSSTransitions();
+
+#ifdef DEBUG_FRAME_DUMP
+public:
+  /**
+   * Get a printable from of the name of the frame type.
+   * XXX This should be eliminated and we use GetType() instead...
+   */
+  virtual nsresult  GetFrameName(nsAString& aResult) const override;
+  nsresult MakeFrameName(const nsAString& aKind, nsAString& aResult) const;
+  // Helper function to return the index in parent of the frame's content
+  // object. Returns -1 on error or if the frame doesn't have a content object
+  static int32_t ContentIndexInContainer(const nsIFrame* aFrame);
+#endif
+
+#ifdef DEBUG
+public:
+  /**
+   * Return the state bits that are relevant to regression tests (that
+   * is, those bits which indicate a real difference when they differ
+   */
+  virtual nsFrameState  GetDebugStateBits() const override;
+  /**
+   * Called to dump out regression data that describes the layout
+   * of the frame and its children, and so on. The format of the
+   * data is dictated to be XML (using a specific DTD); the
+   * specific kind of data dumped is up to the frame itself, with
+   * the caveat that some base types are defined.
+   * For more information, see XXX.
+   */
+  virtual nsresult  DumpRegressionData(nsPresContext* aPresContext,
+                                       FILE* out, int32_t aIndent) override;
+
+  /**
+   * See if style tree verification is enabled. To enable style tree
+   * verification add "styleverifytree:1" to your MOZ_LOG
+   * environment variable (any non-zero debug level will work). Or,
+   * call SetVerifyStyleTreeEnable with true.
+   */
+  static bool GetVerifyStyleTreeEnable();
+
+  /**
+   * Set the verify-style-tree enable flag.
+   */
+  static void SetVerifyStyleTreeEnable(bool aEnabled);
+
+  static mozilla::LazyLogModule sFrameLogModule;
+
+  // Show frame borders when rendering
+  static void ShowFrameBorders(bool aEnable);
+  static bool GetShowFrameBorders();
+
+  // Show frame border of event target
+  static void ShowEventTargetFrameBorder(bool aEnable);
+  static bool GetShowEventTargetFrameBorder();
+
+#endif
+
+public:
+
+  static void PrintDisplayList(nsDisplayListBuilder* aBuilder,
+                               const nsDisplayList& aList,
+                               bool aDumpHtml = false)
+  {
+    std::stringstream ss;
+    PrintDisplayList(aBuilder, aList, ss, aDumpHtml);
+    fprintf_stderr(stderr, "%s", ss.str().c_str());
+  }
+  static void PrintDisplayList(nsDisplayListBuilder* aBuilder,
+                               const nsDisplayList& aList,
+                               std::stringstream& aStream,
+                               bool aDumpHtml = false);
+  static void PrintDisplayListSet(nsDisplayListBuilder* aBuilder,
+                                  const nsDisplayListSet& aList,
+                                  std::stringstream& aStream,
+                                  bool aDumpHtml = false);
+
+};
+
+// Start Display Reflow Debugging
+#ifdef DEBUG
+
+  struct DR_cookie {
+    DR_cookie(nsPresContext*          aPresContext,
+              nsIFrame*                aFrame, 
+              const mozilla::ReflowInput& aReflowInput,
+              mozilla::ReflowOutput&     aMetrics,
+              nsReflowStatus&          aStatus);     
+    ~DR_cookie();
+    void Change() const;
+
+    nsPresContext*          mPresContext;
+    nsIFrame*                mFrame;
+    const mozilla::ReflowInput& mReflowInput;
+    mozilla::ReflowOutput&     mMetrics;
+    nsReflowStatus&          mStatus;    
+    void*                    mValue;
+  };
+
+  struct DR_layout_cookie {
+    explicit DR_layout_cookie(nsIFrame* aFrame);
+    ~DR_layout_cookie();
+
+    nsIFrame* mFrame;
+    void* mValue;
+  };
+  
+  struct DR_intrinsic_width_cookie {
+    DR_intrinsic_width_cookie(nsIFrame* aFrame, const char* aType,
+                              nscoord& aResult);
+    ~DR_intrinsic_width_cookie();
+
+    nsIFrame* mFrame;
+    const char* mType;
+    nscoord& mResult;
+    void* mValue;
+  };
+  
+  struct DR_intrinsic_size_cookie {
+    DR_intrinsic_size_cookie(nsIFrame* aFrame, const char* aType,
+                             nsSize& aResult);
+    ~DR_intrinsic_size_cookie();
+
+    nsIFrame* mFrame;
+    const char* mType;
+    nsSize& mResult;
+    void* mValue;
+  };
+
+  struct DR_init_constraints_cookie {
+    DR_init_constraints_cookie(nsIFrame* aFrame, mozilla::ReflowInput* aState,
+                               nscoord aCBWidth, nscoord aCBHeight,
+                               const nsMargin* aBorder,
+                               const nsMargin* aPadding);
+    ~DR_init_constraints_cookie();
+
+    nsIFrame* mFrame;
+    mozilla::ReflowInput* mState;
+    void* mValue;
+  };
+
+  struct DR_init_offsets_cookie {
+    DR_init_offsets_cookie(nsIFrame* aFrame, mozilla::SizeComputationInput* aState,
+                           const mozilla::LogicalSize& aPercentBasis,
+                           const nsMargin* aBorder,
+                           const nsMargin* aPadding);
+    ~DR_init_offsets_cookie();
+
+    nsIFrame* mFrame;
+    mozilla::SizeComputationInput* mState;
+    void* mValue;
+  };
+
+  struct DR_init_type_cookie {
+    DR_init_type_cookie(nsIFrame* aFrame, mozilla::ReflowInput* aState);
+    ~DR_init_type_cookie();
+
+    nsIFrame* mFrame;
+    mozilla::ReflowInput* mState;
+    void* mValue;
+  };
+
+#define DISPLAY_REFLOW(dr_pres_context, dr_frame, dr_rf_state, dr_rf_metrics, dr_rf_status) \
+  DR_cookie dr_cookie(dr_pres_context, dr_frame, dr_rf_state, dr_rf_metrics, dr_rf_status); 
+#define DISPLAY_REFLOW_CHANGE() \
+  dr_cookie.Change();
+#define DISPLAY_LAYOUT(dr_frame) \
+  DR_layout_cookie dr_cookie(dr_frame); 
+#define DISPLAY_MIN_WIDTH(dr_frame, dr_result) \
+  DR_intrinsic_width_cookie dr_cookie(dr_frame, "Min", dr_result)
+#define DISPLAY_PREF_WIDTH(dr_frame, dr_result) \
+  DR_intrinsic_width_cookie dr_cookie(dr_frame, "Pref", dr_result)
+#define DISPLAY_PREF_SIZE(dr_frame, dr_result) \
+  DR_intrinsic_size_cookie dr_cookie(dr_frame, "Pref", dr_result)
+#define DISPLAY_MIN_SIZE(dr_frame, dr_result) \
+  DR_intrinsic_size_cookie dr_cookie(dr_frame, "Min", dr_result)
+#define DISPLAY_MAX_SIZE(dr_frame, dr_result) \
+  DR_intrinsic_size_cookie dr_cookie(dr_frame, "Max", dr_result)
+#define DISPLAY_INIT_CONSTRAINTS(dr_frame, dr_state, dr_cbw, dr_cbh,       \
+                                 dr_bdr, dr_pad)                           \
+  DR_init_constraints_cookie dr_cookie(dr_frame, dr_state, dr_cbw, dr_cbh, \
+                                       dr_bdr, dr_pad)
+#define DISPLAY_INIT_OFFSETS(dr_frame, dr_state, dr_pb, dr_bdr, dr_pad)  \
+  DR_init_offsets_cookie dr_cookie(dr_frame, dr_state, dr_pb, dr_bdr, dr_pad)
+#define DISPLAY_INIT_TYPE(dr_frame, dr_result) \
+  DR_init_type_cookie dr_cookie(dr_frame, dr_result)
+
+#else
+
+#define DISPLAY_REFLOW(dr_pres_context, dr_frame, dr_rf_state, dr_rf_metrics, dr_rf_status) 
+#define DISPLAY_REFLOW_CHANGE() 
+#define DISPLAY_LAYOUT(dr_frame) PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_MIN_WIDTH(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_PREF_WIDTH(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_PREF_SIZE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_MIN_SIZE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_MAX_SIZE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_INIT_CONSTRAINTS(dr_frame, dr_state, dr_cbw, dr_cbh,       \
+                                 dr_bdr, dr_pad)                           \
+  PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_INIT_OFFSETS(dr_frame, dr_state, dr_pb, dr_bdr, dr_pad)  \
+  PR_BEGIN_MACRO PR_END_MACRO
+#define DISPLAY_INIT_TYPE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO
+
+#endif
+// End Display Reflow Debugging
+
+// similar to NS_ENSURE_TRUE but with no return value
+#define ENSURE_TRUE(x)                                        \
+  PR_BEGIN_MACRO                                              \
+    if (!(x)) {                                               \
+       NS_WARNING("ENSURE_TRUE(" #x ") failed");              \
+       return;                                                \
+    }                                                         \
+  PR_END_MACRO
+#endif /* nsFrame_h___ */