Add m-esr52 at 52.6.0

1 files changed, 4021 insertions, 0 deletions

diff --git a/layout/generic/nsIFrame.h b/layout/generic/nsIFrame.h
new file mode 100644
index 000000000..50eb958e0
--- /dev/null
+++ b/layout/generic/nsIFrame.h
@@ -0,0 +1,4021 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=78: */
+/* 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/. */
+
+/* interface for all rendering objects */
+
+#ifndef nsIFrame_h___
+#define nsIFrame_h___
+
+#ifndef MOZILLA_INTERNAL_API
+#error This header/class should only be used within Mozilla code. It should not be used by extensions.
+#endif
+
+#define MAX_REFLOW_DEPTH 200
+
+/* nsIFrame is in the process of being deCOMtaminated, i.e., this file is eventually
+   going to be eliminated, and all callers will use nsFrame instead.  At the moment
+   we're midway through this process, so you will see inlined functions and member
+   variables in this file.  -dwh */
+
+#include <algorithm>
+#include <stdio.h>
+
+#include "CaretAssociationHint.h"
+#include "FramePropertyTable.h"
+#include "mozilla/layout/FrameChildList.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/WritingModes.h"
+#include "nsDirection.h"
+#include "nsFrameList.h"
+#include "nsFrameState.h"
+#include "mozilla/ReflowOutput.h"
+#include "nsITheme.h"
+#include "nsLayoutUtils.h"
+#include "nsQueryFrame.h"
+#include "nsStringGlue.h"
+#include "nsStyleContext.h"
+#include "nsStyleStruct.h"
+#include "Visibility.h"
+
+#ifdef ACCESSIBILITY
+#include "mozilla/a11y/AccTypes.h"
+#endif
+
+/**
+ * New rules of reflow:
+ * 1. you get a WillReflow() followed by a Reflow() followed by a DidReflow() in order
+ *    (no separate pass over the tree)
+ * 2. it's the parent frame's responsibility to size/position the child's view (not
+ *    the child frame's responsibility as it is today) during reflow (and before
+ *    sending the DidReflow() notification)
+ * 3. positioning of child frames (and their views) is done on the way down the tree,
+ *    and sizing of child frames (and their views) on the way back up
+ * 4. if you move a frame (outside of the reflow process, or after reflowing it),
+ *    then you must make sure that its view (or its child frame's views) are re-positioned
+ *    as well. It's reasonable to not position the view until after all reflowing the
+ *    entire line, for example, but the frame should still be positioned and sized (and
+ *    the view sized) during the reflow (i.e., before sending the DidReflow() notification)
+ * 5. the view system handles moving of widgets, i.e., it's not our problem
+ */
+
+class nsIAtom;
+class nsPresContext;
+class nsIPresShell;
+class nsRenderingContext;
+class nsView;
+class nsIWidget;
+class nsISelectionController;
+class nsBoxLayoutState;
+class nsBoxLayout;
+class nsILineIterator;
+class nsDisplayListBuilder;
+class nsDisplayListSet;
+class nsDisplayList;
+class gfxSkipChars;
+class gfxSkipCharsIterator;
+class gfxContext;
+class nsLineList_iterator;
+class nsAbsoluteContainingBlock;
+class nsIContent;
+class nsContainerFrame;
+
+struct nsPeekOffsetStruct;
+struct nsPoint;
+struct nsRect;
+struct nsSize;
+struct nsMargin;
+struct CharacterDataChangeInfo;
+
+namespace mozilla {
+
+enum class CSSPseudoElementType : uint8_t;
+class EventStates;
+struct ReflowInput;
+class ReflowOutput;
+
+namespace layers {
+class Layer;
+} // namespace layers
+
+namespace gfx {
+class Matrix;
+} // namespace gfx
+} // namespace mozilla
+
+/**
+ * Indication of how the frame can be split. This is used when doing runaround
+ * of floats, and when pulling up child frames from a next-in-flow.
+ *
+ * The choices are splittable, not splittable at all, and splittable in
+ * a non-rectangular fashion. This last type only applies to block-level
+ * elements, and indicates whether splitting can be used when doing runaround.
+ * If you can split across page boundaries, but you expect each continuing
+ * frame to be the same width then return frSplittable and not
+ * frSplittableNonRectangular.
+ *
+ * @see #GetSplittableType()
+ */
+typedef uint32_t nsSplittableType;
+
+#define NS_FRAME_NOT_SPLITTABLE             0   // Note: not a bit!
+#define NS_FRAME_SPLITTABLE                 0x1
+#define NS_FRAME_SPLITTABLE_NON_RECTANGULAR 0x3
+
+#define NS_FRAME_IS_SPLITTABLE(type)\
+  (0 != ((type) & NS_FRAME_SPLITTABLE))
+
+#define NS_FRAME_IS_NOT_SPLITTABLE(type)\
+  (0 == ((type) & NS_FRAME_SPLITTABLE))
+
+#define NS_INTRINSIC_WIDTH_UNKNOWN nscoord_MIN
+
+//----------------------------------------------------------------------
+
+#define NS_SUBTREE_DIRTY(_frame)  \
+  (((_frame)->GetStateBits() &      \
+    (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN)) != 0)
+
+/**
+ * Constant used to indicate an unconstrained size.
+ *
+ * @see #Reflow()
+ */
+#define NS_UNCONSTRAINEDSIZE NS_MAXSIZE
+
+#define NS_INTRINSICSIZE    NS_UNCONSTRAINEDSIZE
+#define NS_AUTOHEIGHT       NS_UNCONSTRAINEDSIZE
+// +1 is to avoid clamped huge margin values being processed as auto margins
+#define NS_AUTOMARGIN       (NS_UNCONSTRAINEDSIZE + 1)
+#define NS_AUTOOFFSET       NS_UNCONSTRAINEDSIZE
+// NOTE: there are assumptions all over that these have the same value, namely NS_UNCONSTRAINEDSIZE
+//       if any are changed to be a value other than NS_UNCONSTRAINEDSIZE
+//       at least update AdjustComputedHeight/Width and test ad nauseum
+
+// 1 million CSS pixels less than our max app unit measure.
+// For reflowing with an "infinite" available inline space per [css-sizing].
+// (reflowing with an NS_UNCONSTRAINEDSIZE available inline size isn't allowed
+//  and leads to assertions)
+#define INFINITE_ISIZE_COORD nscoord(NS_MAXSIZE - (1000000*60))
+
+//----------------------------------------------------------------------
+
+enum nsSelectionAmount {
+  eSelectCharacter = 0, // a single Unicode character;
+                        // do not use this (prefer Cluster) unless you
+                        // are really sure it's what you want
+  eSelectCluster   = 1, // a grapheme cluster: this is usually the right
+                        // choice for movement or selection by "character"
+                        // as perceived by the user
+  eSelectWord      = 2,
+  eSelectWordNoSpace = 3, // select a "word" without selecting the following
+                          // space, no matter what the default platform
+                          // behavior is
+  eSelectLine      = 4, // previous drawn line in flow.
+  // NOTE that selection code depends on the ordering of the above values,
+  // allowing simple <= tests to check categories of caret movement.
+  // Don't rearrange without checking the usage in nsSelection.cpp!
+
+  eSelectBeginLine = 5,
+  eSelectEndLine   = 6,
+  eSelectNoAmount  = 7, // just bounce back current offset.
+  eSelectParagraph = 8  // select a "paragraph"
+};
+
+enum nsSpread {
+  eSpreadNone   = 0,
+  eSpreadAcross = 1,
+  eSpreadDown   = 2
+};
+
+// Carried out margin flags
+#define NS_CARRIED_TOP_MARGIN_IS_AUTO    0x1
+#define NS_CARRIED_BOTTOM_MARGIN_IS_AUTO 0x2
+
+//----------------------------------------------------------------------
+
+/**
+ * Reflow status returned by the reflow methods. There are three
+ * completion statuses, represented by two bit flags.
+ *
+ * NS_FRAME_COMPLETE means the frame is fully complete.
+ *
+ * NS_FRAME_NOT_COMPLETE bit flag means the frame does not map all its
+ * content, and that the parent frame should create a continuing frame.
+ * If this bit isn't set it means the frame does map all its content.
+ * This bit is mutually exclusive with NS_FRAME_OVERFLOW_INCOMPLETE.
+ *
+ * NS_FRAME_OVERFLOW_INCOMPLETE bit flag means that the frame has
+ * overflow that is not complete, but its own box is complete.
+ * (This happens when content overflows a fixed-height box.)
+ * The reflower should place and size the frame and continue its reflow,
+ * but needs to create an overflow container as a continuation for this
+ * frame. See nsContainerFrame.h for more information.
+ * This bit is mutually exclusive with NS_FRAME_NOT_COMPLETE.
+ * 
+ * Please use the SET macro for handling
+ * NS_FRAME_NOT_COMPLETE and NS_FRAME_OVERFLOW_INCOMPLETE.
+ *
+ * NS_FRAME_REFLOW_NEXTINFLOW bit flag means that the next-in-flow is
+ * dirty, and also needs to be reflowed. This status only makes sense
+ * for a frame that is not complete, i.e. you wouldn't set both
+ * NS_FRAME_COMPLETE and NS_FRAME_REFLOW_NEXTINFLOW.
+ *
+ * The low 8 bits of the nsReflowStatus are reserved for future extensions;
+ * the remaining 24 bits are zero (and available for extensions; however
+ * API's that accept/return nsReflowStatus must not receive/return any
+ * extension bits).
+ *
+ * @see #Reflow()
+ */
+typedef uint32_t nsReflowStatus;
+
+#define NS_FRAME_COMPLETE             0       // Note: not a bit!
+#define NS_FRAME_NOT_COMPLETE         0x1
+#define NS_FRAME_REFLOW_NEXTINFLOW    0x2
+#define NS_FRAME_OVERFLOW_INCOMPLETE  0x4
+
+#define NS_FRAME_IS_COMPLETE(status) \
+  (0 == ((status) & NS_FRAME_NOT_COMPLETE))
+
+#define NS_FRAME_IS_NOT_COMPLETE(status) \
+  (0 != ((status) & NS_FRAME_NOT_COMPLETE))
+
+#define NS_FRAME_OVERFLOW_IS_INCOMPLETE(status) \
+  (0 != ((status) & NS_FRAME_OVERFLOW_INCOMPLETE))
+
+#define NS_FRAME_IS_FULLY_COMPLETE(status) \
+  (NS_FRAME_IS_COMPLETE(status) && !NS_FRAME_OVERFLOW_IS_INCOMPLETE(status))
+
+// These macros set or switch incomplete statuses without touching the
+// NS_FRAME_REFLOW_NEXTINFLOW bit.
+#define NS_FRAME_SET_INCOMPLETE(status) \
+  status = (status & ~NS_FRAME_OVERFLOW_INCOMPLETE) | NS_FRAME_NOT_COMPLETE
+
+#define NS_FRAME_SET_OVERFLOW_INCOMPLETE(status) \
+  status = (status & ~NS_FRAME_NOT_COMPLETE) | NS_FRAME_OVERFLOW_INCOMPLETE
+
+// This bit is set, when a break is requested. This bit is orthogonal
+// to the nsIFrame::nsReflowStatus completion bits.
+#define NS_INLINE_BREAK              0x0100
+
+// When a break is requested, this bit when set indicates that the
+// break should occur after the frame just reflowed; when the bit is
+// clear the break should occur before the frame just reflowed.
+#define NS_INLINE_BREAK_BEFORE       0x0000
+#define NS_INLINE_BREAK_AFTER        0x0200
+
+// The type of break requested can be found in these bits.
+#define NS_INLINE_BREAK_TYPE_MASK    0xF000
+
+// Set when a break was induced by completion of a first-letter
+#define NS_INLINE_BREAK_FIRST_LETTER_COMPLETE 0x10000
+
+//----------------------------------------
+// Macros that use those bits
+
+#define NS_INLINE_IS_BREAK(_status) \
+  (0 != ((_status) & NS_INLINE_BREAK))
+
+#define NS_INLINE_IS_BREAK_AFTER(_status) \
+  (0 != ((_status) & NS_INLINE_BREAK_AFTER))
+
+#define NS_INLINE_IS_BREAK_BEFORE(_status) \
+  (NS_INLINE_BREAK == ((_status) & (NS_INLINE_BREAK|NS_INLINE_BREAK_AFTER)))
+
+#define NS_INLINE_GET_BREAK_TYPE(_status) \
+  (static_cast<StyleClear>(((_status) >> 12) & 0xF))
+
+#define NS_INLINE_MAKE_BREAK_TYPE(_type)  (static_cast<int>(_type) << 12)
+
+// Construct a line-break-before status. Note that there is no
+// completion status for a line-break before because we *know* that
+// the frame will be reflowed later and hence its current completion
+// status doesn't matter.
+#define NS_INLINE_LINE_BREAK_BEFORE()                                   \
+  (NS_INLINE_BREAK | NS_INLINE_BREAK_BEFORE |                           \
+   NS_INLINE_MAKE_BREAK_TYPE(StyleClear::Line))
+
+// Take a completion status and add to it the desire to have a
+// line-break after. For this macro we do need the completion status
+// because the user of the status will need to know whether to
+// continue the frame or not.
+#define NS_INLINE_LINE_BREAK_AFTER(_completionStatus)                   \
+  ((_completionStatus) | NS_INLINE_BREAK | NS_INLINE_BREAK_AFTER |      \
+   NS_INLINE_MAKE_BREAK_TYPE(StyleClear::Line))
+
+// A frame is "truncated" if the part of the frame before the first
+// possible break point was unable to fit in the available vertical
+// space.  Therefore, the entire frame should be moved to the next page.
+// A frame that begins at the top of the page must never be "truncated".
+// Doing so would likely cause an infinite loop.
+#define NS_FRAME_TRUNCATED  0x0010
+#define NS_FRAME_IS_TRUNCATED(status) \
+  (0 != ((status) & NS_FRAME_TRUNCATED))
+#define NS_FRAME_SET_TRUNCATION(status, aReflowInput, aMetrics) \
+  aReflowInput.SetTruncated(aMetrics, &status);
+
+// Merge the incompleteness, truncation and NS_FRAME_REFLOW_NEXTINFLOW
+// status from aSecondary into aPrimary.
+void NS_MergeReflowStatusInto(nsReflowStatus* aPrimary,
+                              nsReflowStatus aSecondary);
+
+//----------------------------------------------------------------------
+
+/**
+ * DidReflow status values.
+ */
+enum class nsDidReflowStatus : uint32_t {
+  NOT_FINISHED,
+  FINISHED
+};
+
+/**
+ * When there is no scrollable overflow rect, the visual overflow rect
+ * may be stored as four 1-byte deltas each strictly LESS THAN 0xff, for
+ * the four edges of the rectangle, or the four bytes may be read as a
+ * single 32-bit "overflow-rect type" value including at least one 0xff
+ * byte as an indicator that the value does NOT represent four deltas.
+ * If all four deltas are zero, this means that no overflow rect has
+ * actually been set (this is the initial state of newly-created frames).
+ */
+#define NS_FRAME_OVERFLOW_DELTA_MAX     0xfe // max delta we can store
+
+#define NS_FRAME_OVERFLOW_NONE    0x00000000 // there are no overflow rects;
+                                             // code relies on this being
+                                             // the all-zero value
+
+#define NS_FRAME_OVERFLOW_LARGE   0x000000ff // overflow is stored as a
+                                             // separate rect property
+
+/**
+ * nsBidiLevel is the type of the level values in our Unicode Bidi
+ * implementation.
+ * It holds an embedding level and indicates the visual direction
+ * by its bit 0 (even/odd value).<p>
+ *
+ * <li><code>aParaLevel</code> can be set to the
+ * pseudo-level values <code>NSBIDI_DEFAULT_LTR</code>
+ * and <code>NSBIDI_DEFAULT_RTL</code>.</li></ul>
+ *
+ * @see nsBidi::SetPara
+ *
+ * <p>The related constants are not real, valid level values.
+ * <code>NSBIDI_DEFAULT_XXX</code> can be used to specify
+ * a default for the paragraph level for
+ * when the <code>SetPara</code> function
+ * shall determine it but there is no
+ * strongly typed character in the input.<p>
+ *
+ * Note that the value for <code>NSBIDI_DEFAULT_LTR</code> is even
+ * and the one for <code>NSBIDI_DEFAULT_RTL</code> is odd,
+ * just like with normal LTR and RTL level values -
+ * these special values are designed that way. Also, the implementation
+ * assumes that NSBIDI_MAX_EXPLICIT_LEVEL is odd.
+ *
+ * @see NSBIDI_DEFAULT_LTR
+ * @see NSBIDI_DEFAULT_RTL
+ * @see NSBIDI_LEVEL_OVERRIDE
+ * @see NSBIDI_MAX_EXPLICIT_LEVEL
+ */
+typedef uint8_t nsBidiLevel;
+
+/** Paragraph level setting.
+ *  If there is no strong character, then set the paragraph level to 0 (left-to-right).
+ */
+#define NSBIDI_DEFAULT_LTR 0xfe
+
+/** Paragraph level setting.
+ *  If there is no strong character, then set the paragraph level to 1 (right-to-left).
+ */
+#define NSBIDI_DEFAULT_RTL 0xff
+
+/**
+ * Maximum explicit embedding level.
+ * (The maximum resolved level can be up to <code>NSBIDI_MAX_EXPLICIT_LEVEL+1</code>).
+ *
+ */
+#define NSBIDI_MAX_EXPLICIT_LEVEL 125
+
+/** Bit flag for level input.
+ *  Overrides directional properties.
+ */
+#define NSBIDI_LEVEL_OVERRIDE 0x80
+
+/**
+ * <code>nsBidiDirection</code> values indicate the text direction.
+ */
+enum nsBidiDirection {
+  /** All left-to-right text This is a 0 value. */
+  NSBIDI_LTR,
+  /** All right-to-left text This is a 1 value. */
+  NSBIDI_RTL,
+  /** Mixed-directional text. */
+  NSBIDI_MIXED
+};
+
+namespace mozilla {
+
+// https://drafts.csswg.org/css-align-3/#baseline-sharing-group
+enum BaselineSharingGroup
+{
+  // NOTE Used as an array index so must be 0 and 1.
+  eFirst = 0,
+  eLast = 1,
+};
+
+// Loosely: https://drafts.csswg.org/css-align-3/#shared-alignment-context
+enum class AlignmentContext
+{
+  eInline,
+  eTable,
+  eFlexbox,
+  eGrid,
+};
+
+/*
+ * For replaced elements only. Gets the intrinsic dimensions of this element.
+ * The dimensions may only be one of the following two types:
+ *
+ *   eStyleUnit_Coord   - a length in app units
+ *   eStyleUnit_None    - the element has no intrinsic size in this dimension
+ */
+struct IntrinsicSize {
+  nsStyleCoord width, height;
+
+  IntrinsicSize()
+    : width(eStyleUnit_None), height(eStyleUnit_None)
+  {}
+  IntrinsicSize(const IntrinsicSize& rhs)
+    : width(rhs.width), height(rhs.height)
+  {}
+  IntrinsicSize& operator=(const IntrinsicSize& rhs) {
+    width = rhs.width; height = rhs.height; return *this;
+  }
+  bool operator==(const IntrinsicSize& rhs) {
+    return width == rhs.width && height == rhs.height;
+  }
+  bool operator!=(const IntrinsicSize& rhs) {
+    return !(*this == rhs);
+  }
+};
+
+// Pseudo bidi embedding level indicating nonexistence.
+static const nsBidiLevel kBidiLevelNone = 0xff;
+
+struct FrameBidiData
+{
+  nsBidiLevel baseLevel;
+  nsBidiLevel embeddingLevel;
+  // The embedding level of virtual bidi formatting character before
+  // this frame if any. kBidiLevelNone is used to indicate nonexistence
+  // or unnecessity of such virtual character.
+  nsBidiLevel precedingControl;
+};
+
+} // namespace mozilla
+
+/// Generic destructor for frame properties. Calls delete.
+template<typename T>
+static void DeleteValue(T* aPropertyValue)
+{
+  delete aPropertyValue;
+}
+
+/// Generic destructor for frame properties. Calls Release().
+template<typename T>
+static void ReleaseValue(T* aPropertyValue)
+{
+  aPropertyValue->Release();
+}
+
+//----------------------------------------------------------------------
+
+/**
+ * A frame in the layout model. This interface is supported by all frame
+ * objects.
+ *
+ * Frames can have multiple child lists: the default child list
+ * (referred to as the <i>principal</i> child list, and additional named
+ * child lists. There is an ordering of frames within a child list, but
+ * there is no order defined between frames in different child lists of
+ * the same parent frame.
+ *
+ * Frames are NOT reference counted. Use the Destroy() member function
+ * to destroy a frame. The lifetime of the frame hierarchy is bounded by the
+ * lifetime of the presentation shell which owns the frames.
+ *
+ * nsIFrame is a private Gecko interface. If you are not Gecko then you
+ * should not use it. If you're not in layout, then you won't be able to
+ * link to many of the functions defined here. Too bad.
+ *
+ * If you're not in layout but you must call functions in here, at least
+ * restrict yourself to calling virtual methods, which won't hurt you as badly.
+ */
+class nsIFrame : public nsQueryFrame
+{
+public:
+  using AlignmentContext = mozilla::AlignmentContext;
+  using BaselineSharingGroup = mozilla::BaselineSharingGroup;
+  template <typename T> using Maybe = mozilla::Maybe<T>;
+  using Nothing = mozilla::Nothing;
+  using OnNonvisible = mozilla::OnNonvisible;
+  template<typename T=void>
+  using PropertyDescriptor = const mozilla::FramePropertyDescriptor<T>*;
+  using ReflowInput = mozilla::ReflowInput;
+  using ReflowOutput = mozilla::ReflowOutput;
+  using Visibility = mozilla::Visibility;
+
+  typedef mozilla::FrameProperties FrameProperties;
+  typedef mozilla::layers::Layer Layer;
+  typedef mozilla::layout::FrameChildList ChildList;
+  typedef mozilla::layout::FrameChildListID ChildListID;
+  typedef mozilla::layout::FrameChildListIDs ChildListIDs;
+  typedef mozilla::layout::FrameChildListIterator ChildListIterator;
+  typedef mozilla::layout::FrameChildListArrayIterator ChildListArrayIterator;
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+  typedef mozilla::gfx::Matrix Matrix;
+  typedef mozilla::gfx::Matrix4x4 Matrix4x4;
+  typedef mozilla::Sides Sides;
+  typedef mozilla::LogicalSides LogicalSides;
+
+  NS_DECL_QUERYFRAME_TARGET(nsIFrame)
+
+  nsPresContext* PresContext() const {
+    return StyleContext()->PresContext();
+  }
+
+  /**
+   * Called to initialize the frame. This is called immediately after creating
+   * the frame.
+   *
+   * If the frame is a continuing frame, then aPrevInFlow indicates the previous
+   * frame (the frame that was split).
+   *
+   * If you want a view associated with your frame, you should create the view
+   * after Init() has returned.
+   *
+   * @param   aContent the content object associated with the frame
+   * @param   aParent the parent frame
+   * @param   aPrevInFlow the prev-in-flow frame
+   */
+  virtual void Init(nsIContent*       aContent,
+                    nsContainerFrame* aParent,
+                    nsIFrame*         aPrevInFlow) = 0;
+
+  /**
+   * Destroys this frame and each of its child frames (recursively calls
+   * Destroy() for each child). If this frame is a first-continuation, this
+   * also removes the frame from the primary frame map and clears undisplayed
+   * content for its content node.
+   * If the frame is a placeholder, it also ensures the out-of-flow frame's
+   * removal and destruction.
+   */
+  void Destroy() { DestroyFrom(this); }
+ 
+  /** Flags for PeekOffsetCharacter, PeekOffsetNoAmount, PeekOffsetWord return values.
+    */
+  enum FrameSearchResult {
+    // Peek found a appropriate offset within frame.
+    FOUND = 0x00,
+    // try next frame for offset.
+    CONTINUE = 0x1,
+    // offset not found because the frame was empty of text.
+    CONTINUE_EMPTY = 0x2 | CONTINUE,
+    // offset not found because the frame didn't contain any text that could be selected.
+    CONTINUE_UNSELECTABLE = 0x4 | CONTINUE,
+  };
+
+protected:
+  /**
+   * Return true if the frame is part of a Selection.
+   * Helper method to implement the public IsSelected() API.
+   */
+  virtual bool IsFrameSelected() const;
+
+  /**
+   * Implements Destroy(). Do not call this directly except from within a
+   * DestroyFrom() implementation.
+   *
+   * @note This will always be called, so it is not necessary to override
+   *       Destroy() in subclasses of nsFrame, just DestroyFrom().
+   *
+   * @param  aDestructRoot is the root of the subtree being destroyed
+   */
+  virtual void DestroyFrom(nsIFrame* aDestructRoot) = 0;
+  friend class nsFrameList; // needed to pass aDestructRoot through to children
+  friend class nsLineBox;   // needed to pass aDestructRoot through to children
+  friend class nsContainerFrame; // needed to pass aDestructRoot through to children
+  friend class nsFrame; // need to assign mParent
+public:
+
+  /**
+   * Get the content object associated with this frame. Does not add a reference.
+   */
+  nsIContent* GetContent() const { return mContent; }
+
+  /**
+   * Get the frame that should be the parent for the frames of child elements
+   * May return nullptr during reflow
+   */
+  virtual nsContainerFrame* GetContentInsertionFrame() { return nullptr; }
+
+  /**
+   * Move any frames on our overflow list to the end of our principal list.
+   * @return true if there were any overflow frames
+   */
+  virtual bool DrainSelfOverflowList() { return false; }
+
+  /**
+   * Get the frame that should be scrolled if the content associated
+   * with this frame is targeted for scrolling. For frames implementing
+   * nsIScrollableFrame this will return the frame itself. For frames
+   * like nsTextControlFrame that contain a scrollframe, will return
+   * that scrollframe.
+   */
+  virtual nsIScrollableFrame* GetScrollTargetFrame() { return nullptr; }
+
+  /**
+   * Get the offsets of the frame. most will be 0,0
+   *
+   */
+  virtual nsresult GetOffsets(int32_t &start, int32_t &end) const = 0;
+
+  /**
+   * Reset the offsets when splitting frames during Bidi reordering
+   *
+   */
+  virtual void AdjustOffsetsForBidi(int32_t aStart, int32_t aEnd) {}
+
+  /**
+   * Get the style context associated with this frame.
+   */
+  nsStyleContext* StyleContext() const { return mStyleContext; }
+  void SetStyleContext(nsStyleContext* aContext)
+  { 
+    if (aContext != mStyleContext) {
+      nsStyleContext* oldStyleContext = mStyleContext;
+      mStyleContext = aContext;
+      aContext->AddRef();
+#ifdef DEBUG
+      aContext->FrameAddRef();
+#endif
+      DidSetStyleContext(oldStyleContext);
+#ifdef DEBUG
+      oldStyleContext->FrameRelease();
+#endif
+      oldStyleContext->Release();
+    }
+  }
+
+  /**
+   * SetStyleContextWithoutNotification is for changes to the style
+   * context that should suppress style change processing, in other
+   * words, those that aren't really changes.  This generally means only
+   * changes that happen during frame construction.
+   */
+  void SetStyleContextWithoutNotification(nsStyleContext* aContext)
+  {
+    if (aContext != mStyleContext) {
+#ifdef DEBUG
+      mStyleContext->FrameRelease();
+#endif
+      mStyleContext->Release();
+      mStyleContext = aContext;
+      aContext->AddRef();
+#ifdef DEBUG
+      aContext->FrameAddRef();
+#endif
+    }
+  }
+
+  // Style post processing hook
+  // Attention: the old style context is the one we're forgetting,
+  // and hence possibly completely bogus for GetStyle* purposes.
+  // Use PeekStyleData instead.
+  virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) = 0;
+
+  /**
+   * Define typesafe getter functions for each style struct by
+   * preprocessing the list of style structs.  These functions are the
+   * preferred way to get style data.  The macro creates functions like:
+   *   const nsStyleBorder* StyleBorder();
+   *   const nsStyleColor* StyleColor();
+   *
+   * Callers outside of libxul should use nsIDOMWindow::GetComputedStyle()
+   * instead of these accessors.
+   */
+  #define STYLE_STRUCT(name_, checkdata_cb_)                                  \
+    const nsStyle##name_ * Style##name_ () const {                            \
+      NS_ASSERTION(mStyleContext, "No style context found!");                 \
+      return mStyleContext->Style##name_ ();                                  \
+    }
+  #include "nsStyleStructList.h"
+  #undef STYLE_STRUCT
+
+  /** Also forward GetVisitedDependentColor to the style context */
+  nscolor GetVisitedDependentColor(nsCSSPropertyID aProperty)
+    { return mStyleContext->GetVisitedDependentColor(aProperty); }
+
+  /**
+   * These methods are to access any additional style contexts that
+   * the frame may be holding. These are contexts that are children
+   * of the frame's primary context and are NOT used as style contexts
+   * for any child frames. These contexts also MUST NOT have any child 
+   * contexts whatsoever. If you need to insert style contexts into the
+   * style tree, then you should create pseudo element frames to own them
+   * The indicies must be consecutive and implementations MUST return an 
+   * NS_ERROR_INVALID_ARG if asked for an index that is out of range.
+   */
+  virtual nsStyleContext* GetAdditionalStyleContext(int32_t aIndex) const = 0;
+
+  virtual void SetAdditionalStyleContext(int32_t aIndex,
+                                         nsStyleContext* aStyleContext) = 0;
+
+  /**
+   * Accessor functions for geometric parent.
+   */
+  nsContainerFrame* GetParent() const { return mParent; }
+  /**
+   * Set this frame's parent to aParent.
+   * If the frame may have moved into or out of a scrollframe's
+   * frame subtree, StickyScrollContainer::NotifyReparentedFrameAcrossScrollFrameBoundary
+   * must also be called.
+   */
+  void SetParent(nsContainerFrame* aParent);
+
+  /**
+   * The frame's writing-mode, used for logical layout computations.
+   */
+  virtual mozilla::WritingMode GetWritingMode() const {
+    return mozilla::WritingMode(StyleContext());
+  }
+
+  /**
+   * Get the writing mode of this frame, but if it is styled with
+   * unicode-bidi: plaintext, reset the direction to the resolved paragraph
+   * level of the given subframe (typically the first frame on the line),
+   * not this frame's writing mode, because the container frame could be split
+   * by hard line breaks into multiple paragraphs with different base direction.
+   */
+  mozilla::WritingMode GetWritingMode(nsIFrame* aSubFrame) const;
+
+  /**
+   * Bounding rect of the frame. The values are in app units, and the origin is
+   * relative to the upper-left of the geometric parent. The size includes the
+   * content area, borders, and padding.
+   *
+   * Note: moving or sizing the frame does not affect the view's size or
+   * position.
+   */
+  nsRect GetRect() const { return mRect; }
+  nsPoint GetPosition() const { return mRect.TopLeft(); }
+  nsSize GetSize() const { return mRect.Size(); }
+  nsRect GetRectRelativeToSelf() const {
+    return nsRect(nsPoint(0, 0), mRect.Size());
+  }
+  /**
+   * Dimensions and position in logical coordinates in the frame's writing mode
+   *  or another writing mode
+   */
+  mozilla::LogicalRect GetLogicalRect(const nsSize& aContainerSize) const {
+    return GetLogicalRect(GetWritingMode(), aContainerSize);
+  }
+  mozilla::LogicalPoint GetLogicalPosition(const nsSize& aContainerSize) const {
+    return GetLogicalPosition(GetWritingMode(), aContainerSize);
+  }
+  mozilla::LogicalSize GetLogicalSize() const {
+    return GetLogicalSize(GetWritingMode());
+  }
+  mozilla::LogicalRect GetLogicalRect(mozilla::WritingMode aWritingMode,
+                                      const nsSize& aContainerSize) const {
+    return mozilla::LogicalRect(aWritingMode, GetRect(), aContainerSize);
+  }
+  mozilla::LogicalPoint GetLogicalPosition(mozilla::WritingMode aWritingMode,
+                                           const nsSize& aContainerSize) const {
+    return GetLogicalRect(aWritingMode, aContainerSize).Origin(aWritingMode);
+  }
+  mozilla::LogicalSize GetLogicalSize(mozilla::WritingMode aWritingMode) const {
+    return mozilla::LogicalSize(aWritingMode, GetSize());
+  }
+  nscoord IStart(const nsSize& aContainerSize) const {
+    return IStart(GetWritingMode(), aContainerSize);
+  }
+  nscoord IStart(mozilla::WritingMode aWritingMode,
+                 const nsSize& aContainerSize) const {
+    return GetLogicalPosition(aWritingMode, aContainerSize).I(aWritingMode);
+  }
+  nscoord BStart(const nsSize& aContainerSize) const {
+    return BStart(GetWritingMode(), aContainerSize);
+  }
+  nscoord BStart(mozilla::WritingMode aWritingMode,
+                 const nsSize& aContainerSize) const {
+    return GetLogicalPosition(aWritingMode, aContainerSize).B(aWritingMode);
+  }
+  nscoord ISize() const { return ISize(GetWritingMode()); }
+  nscoord ISize(mozilla::WritingMode aWritingMode) const {
+    return GetLogicalSize(aWritingMode).ISize(aWritingMode);
+  }
+  nscoord BSize() const { return BSize(GetWritingMode()); }
+  nscoord BSize(mozilla::WritingMode aWritingMode) const {
+    return GetLogicalSize(aWritingMode).BSize(aWritingMode);
+  }
+  nscoord ContentBSize() const { return ContentBSize(GetWritingMode()); }
+  nscoord ContentBSize(mozilla::WritingMode aWritingMode) const {
+    auto bp = GetLogicalUsedBorderAndPadding(aWritingMode);
+    bp.ApplySkipSides(GetLogicalSkipSides());
+    return std::max(0, BSize(aWritingMode) - bp.BStartEnd(aWritingMode));
+  }
+
+  /**
+   * When we change the size of the frame's border-box rect, we may need to
+   * reset the overflow rect if it was previously stored as deltas.
+   * (If it is currently a "large" overflow and could be re-packed as deltas,
+   * we don't bother as the cost of the allocation has already been paid.)
+   */
+  void SetRect(const nsRect& aRect) {
+    if (mOverflow.mType != NS_FRAME_OVERFLOW_LARGE &&
+        mOverflow.mType != NS_FRAME_OVERFLOW_NONE) {
+      nsOverflowAreas overflow = GetOverflowAreas();
+      mRect = aRect;
+      SetOverflowAreas(overflow);
+    } else {
+      mRect = aRect;
+    }
+  }
+  /**
+   * Set this frame's rect from a logical rect in its own writing direction
+   */
+  void SetRect(const mozilla::LogicalRect& aRect,
+               const nsSize& aContainerSize) {
+    SetRect(GetWritingMode(), aRect, aContainerSize);
+  }
+  /**
+   * Set this frame's rect from a logical rect in a different writing direction
+   * (GetPhysicalRect will assert if the writing mode doesn't match)
+   */
+  void SetRect(mozilla::WritingMode aWritingMode,
+               const mozilla::LogicalRect& aRect,
+               const nsSize& aContainerSize) {
+    SetRect(aRect.GetPhysicalRect(aWritingMode, aContainerSize));
+  }
+
+  /**
+   * Set this frame's size from a logical size in its own writing direction.
+   * This leaves the frame's logical position unchanged, which means its
+   * physical position may change (for right-to-left modes).
+   */
+  void SetSize(const mozilla::LogicalSize& aSize) {
+    SetSize(GetWritingMode(), aSize);
+  }
+  /*
+   * Set this frame's size from a logical size in a different writing direction.
+   * This leaves the frame's logical position in the given mode unchanged,
+   * which means its physical position may change (for right-to-left modes).
+   */
+  void SetSize(mozilla::WritingMode aWritingMode,
+               const mozilla::LogicalSize& aSize)
+  {
+    if ((!aWritingMode.IsVertical() && !aWritingMode.IsBidiLTR()) ||
+        aWritingMode.IsVerticalRL()) {
+      nscoord oldWidth = mRect.width;
+      SetSize(aSize.GetPhysicalSize(aWritingMode));
+      mRect.x -= mRect.width - oldWidth;
+    } else {
+      SetSize(aSize.GetPhysicalSize(aWritingMode));
+    }
+  }
+
+  /**
+   * Set this frame's physical size. This leaves the frame's physical position
+   * (topLeft) unchanged.
+   */
+  void SetSize(const nsSize& aSize) {
+    SetRect(nsRect(mRect.TopLeft(), aSize));
+  }
+
+  void SetPosition(const nsPoint& aPt) { mRect.MoveTo(aPt); }
+  void SetPosition(mozilla::WritingMode aWritingMode,
+                   const mozilla::LogicalPoint& aPt,
+                   const nsSize& aContainerSize) {
+    // We subtract mRect.Size() from the container size to account for
+    // the fact that logical origins in RTL coordinate systems are at
+    // the top right of the frame instead of the top left.
+    mRect.MoveTo(aPt.GetPhysicalPoint(aWritingMode,
+                                      aContainerSize - mRect.Size()));
+  }
+
+  /**
+   * Move the frame, accounting for relative positioning. Use this when
+   * adjusting the frame's position by a known amount, to properly update its
+   * saved normal position (see GetNormalPosition below).
+   *
+   * This must be used only when moving a frame *after*
+   * ReflowInput::ApplyRelativePositioning is called.  When moving
+   * a frame during the reflow process prior to calling
+   * ReflowInput::ApplyRelativePositioning, the position should
+   * simply be adjusted directly (e.g., using SetPosition()).
+   */
+  void MovePositionBy(const nsPoint& aTranslation);
+
+  /**
+   * As above, using a logical-point delta in a given writing mode.
+   */
+  void MovePositionBy(mozilla::WritingMode aWritingMode,
+                      const mozilla::LogicalPoint& aTranslation)
+  {
+    // The LogicalPoint represents a vector rather than a point within a
+    // rectangular coordinate space, so we use a null containerSize when
+    // converting logical to physical.
+    const nsSize nullContainerSize;
+    MovePositionBy(aTranslation.GetPhysicalPoint(aWritingMode,
+                                                 nullContainerSize));
+  }
+
+  /**
+   * Return frame's rect without relative positioning
+   */
+  nsRect GetNormalRect() const;
+
+  /**
+   * Return frame's position without relative positioning
+   */
+  nsPoint GetNormalPosition() const;
+  mozilla::LogicalPoint
+  GetLogicalNormalPosition(mozilla::WritingMode aWritingMode,
+                           const nsSize& aContainerSize) const
+  {
+    // Subtract the size of this frame from the container size to get
+    // the correct position in rtl frames where the origin is on the
+    // right instead of the left
+    return mozilla::LogicalPoint(aWritingMode,
+                                 GetNormalPosition(),
+                                 aContainerSize - mRect.Size());
+  }
+
+  virtual nsPoint GetPositionOfChildIgnoringScrolling(nsIFrame* aChild)
+  { return aChild->GetPosition(); }
+  
+  nsPoint GetPositionIgnoringScrolling();
+
+  typedef AutoTArray<nsIContent*, 2> ContentArray;
+  static void DestroyContentArray(ContentArray* aArray);
+
+#define NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, dtor)             \
+  static const mozilla::FramePropertyDescriptor<type>* prop() {           \
+    /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */    \
+    static const auto descriptor =                                        \
+      mozilla::FramePropertyDescriptor<type>::NewWithDestructor<dtor>();  \
+    return &descriptor;                                                   \
+  }
+
+// Don't use this unless you really know what you're doing!
+#define NS_DECLARE_FRAME_PROPERTY_WITH_FRAME_IN_DTOR(prop, type, dtor)    \
+  static const mozilla::FramePropertyDescriptor<type>* prop() {           \
+    /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */    \
+    static const auto descriptor = mozilla::                              \
+      FramePropertyDescriptor<type>::NewWithDestructorWithFrame<dtor>();  \
+    return &descriptor;                                                   \
+  }
+
+#define NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(prop, type)                \
+  static const mozilla::FramePropertyDescriptor<type>* prop() {           \
+    /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */    \
+    static const auto descriptor =                                        \
+      mozilla::FramePropertyDescriptor<type>::NewWithoutDestructor();     \
+    return &descriptor;                                                   \
+  }
+
+#define NS_DECLARE_FRAME_PROPERTY_DELETABLE(prop, type) \
+  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, DeleteValue)
+
+#define NS_DECLARE_FRAME_PROPERTY_RELEASABLE(prop, type) \
+  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, ReleaseValue)
+
+#define NS_DECLARE_FRAME_PROPERTY_WITH_DTOR_NEVER_CALLED(prop, type)  \
+  static void AssertOnDestroyingProperty##prop(type*) {               \
+    MOZ_ASSERT_UNREACHABLE("Frame property " #prop " should never "   \
+                           "be destroyed by the FramePropertyTable"); \
+  }                                                                   \
+  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type,                     \
+                                      AssertOnDestroyingProperty##prop)
+
+#define NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(prop, type) \
+  NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(prop, mozilla::SmallValueHolder<type>)
+
+  NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(IBSplitSibling, nsIFrame)
+  NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(IBSplitPrevSibling, nsIFrame)
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(NormalPositionProperty, nsPoint)
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(ComputedOffsetProperty, nsMargin)
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(OutlineInnerRectProperty, nsRect)
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(PreEffectsBBoxProperty, nsRect)
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(PreTransformOverflowAreasProperty,
+                                      nsOverflowAreas)
+
+  // The initial overflow area passed to FinishAndStoreOverflow. This is only set
+  // on frames that Preserve3D() or HasPerspective() or IsTransformed(), and
+  // when at least one of the overflow areas differs from the frame bound rect.
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(InitialOverflowProperty, nsOverflowAreas)
+
+#ifdef DEBUG
+  // InitialOverflowPropertyDebug is added to the frame to indicate that either
+  // the InitialOverflowProperty has been stored or the InitialOverflowProperty
+  // has been suppressed due to being set to the default value (frame bounds)
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(DebugInitialOverflowPropertyApplied, bool)
+#endif
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(UsedMarginProperty, nsMargin)
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(UsedPaddingProperty, nsMargin)
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(UsedBorderProperty, nsMargin)
+
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(LineBaselineOffset, nscoord)
+
+  // Temporary override for a flex item's main-size property (either width
+  // or height), imposed by its flex container.
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(FlexItemMainSizeOverride, nscoord)
+
+  NS_DECLARE_FRAME_PROPERTY_RELEASABLE(CachedBackgroundImageDT, DrawTarget)
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(InvalidationRect, nsRect)
+
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(RefusedAsyncAnimationProperty, bool)
+
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(FragStretchBSizeProperty, nscoord)
+
+  // The block-axis margin-box size associated with eBClampMarginBoxMinSize.
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BClampMarginBoxMinSizeProperty, nscoord)
+
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(IBaselinePadProperty, nscoord)
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BBaselinePadProperty, nscoord)
+
+  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(GenConProperty, ContentArray,
+                                      DestroyContentArray)
+
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BidiDataProperty, mozilla::FrameBidiData)
+
+  mozilla::FrameBidiData GetBidiData()
+  {
+    return Properties().Get(BidiDataProperty());
+  }
+
+  nsBidiLevel GetBaseLevel()
+  {
+    return GetBidiData().baseLevel;
+  }
+
+  nsBidiLevel GetEmbeddingLevel()
+  {
+    return GetBidiData().embeddingLevel;
+  }
+
+  nsTArray<nsIContent*>* GetGenConPseudos() {
+    return Properties().Get(GenConProperty());
+  }
+
+  /**
+   * Return the distance between the border edge of the frame and the
+   * margin edge of the frame.  Like GetRect(), returns the dimensions
+   * as of the most recent reflow.
+   *
+   * This doesn't include any margin collapsing that may have occurred.
+   *
+   * It also treats 'auto' margins as zero, and treats any margins that
+   * should have been turned into 'auto' because of overconstraint as
+   * having their original values.
+   */
+  virtual nsMargin GetUsedMargin() const;
+  virtual mozilla::LogicalMargin
+  GetLogicalUsedMargin(mozilla::WritingMode aWritingMode) const {
+    return mozilla::LogicalMargin(aWritingMode, GetUsedMargin());
+  }
+
+  /**
+   * Return the distance between the border edge of the frame (which is
+   * its rect) and the padding edge of the frame. Like GetRect(), returns
+   * the dimensions as of the most recent reflow.
+   *
+   * Note that this differs from StyleBorder()->GetComputedBorder() in
+   * that this describes a region of the frame's box, and
+   * StyleBorder()->GetComputedBorder() describes a border.  They differ
+   * for tables (particularly border-collapse tables) and themed
+   * elements.
+   */
+  virtual nsMargin GetUsedBorder() const;
+  virtual mozilla::LogicalMargin
+  GetLogicalUsedBorder(mozilla::WritingMode aWritingMode) const {
+    return mozilla::LogicalMargin(aWritingMode, GetUsedBorder());
+  }
+
+  /**
+   * Return the distance between the padding edge of the frame and the
+   * content edge of the frame.  Like GetRect(), returns the dimensions
+   * as of the most recent reflow.
+   */
+  virtual nsMargin GetUsedPadding() const;
+  virtual mozilla::LogicalMargin
+  GetLogicalUsedPadding(mozilla::WritingMode aWritingMode) const {
+    return mozilla::LogicalMargin(aWritingMode, GetUsedPadding());
+  }
+
+  nsMargin GetUsedBorderAndPadding() const {
+    return GetUsedBorder() + GetUsedPadding();
+  }
+  mozilla::LogicalMargin
+  GetLogicalUsedBorderAndPadding(mozilla::WritingMode aWritingMode) const {
+    return mozilla::LogicalMargin(aWritingMode, GetUsedBorderAndPadding());
+  }
+
+  /**
+   * Like the frame's rect (see |GetRect|), which is the border rect,
+   * other rectangles of the frame, in app units, relative to the parent.
+   */
+  nsRect GetPaddingRect() const;
+  nsRect GetPaddingRectRelativeToSelf() const;
+  nsRect GetContentRect() const;
+  nsRect GetContentRectRelativeToSelf() const;
+  nsRect GetMarginRectRelativeToSelf() const;
+
+  /**
+   * The area to paint box-shadows around.  The default is the border rect.
+   * (nsFieldSetFrame overrides this).
+   */
+  virtual nsRect VisualBorderRectRelativeToSelf() const {
+    return nsRect(0, 0, mRect.width, mRect.height);
+  }
+
+  /**
+   * Get the size, in app units, of the border radii. It returns FALSE iff all
+   * returned radii == 0 (so no border radii), TRUE otherwise.
+   * For the aRadii indexes, use the NS_CORNER_* constants in nsStyleConsts.h
+   * If a side is skipped via aSkipSides, its corners are forced to 0.
+   *
+   * All corner radii are then adjusted so they do not require more
+   * space than aBorderArea, according to the algorithm in css3-background.
+   *
+   * aFrameSize is used as the basis for percentage widths and heights.
+   * aBorderArea is used for the adjustment of radii that might be too
+   * large.
+   * FIXME: In the long run, we can probably get away with only one of
+   * these, especially if we change the way we handle outline-radius (by
+   * removing it and inflating the border radius)
+   *
+   * Return whether any radii are nonzero.
+   */
+  static bool ComputeBorderRadii(const nsStyleCorners& aBorderRadius,
+                                 const nsSize& aFrameSize,
+                                 const nsSize& aBorderArea,
+                                 Sides aSkipSides,
+                                 nscoord aRadii[8]);
+
+  /*
+   * Given a set of border radii for one box (e.g., border box), convert
+   * it to the equivalent set of radii for another box (e.g., in to
+   * padding box, out to outline box) by reducing radii or increasing
+   * nonzero radii as appropriate.
+   *
+   * Indices into aRadii are the NS_CORNER_* constants in nsStyleConsts.h
+   *
+   * Note that InsetBorderRadii is lossy, since it can turn nonzero
+   * radii into zero, and OutsetBorderRadii does not inflate zero radii.
+   * Therefore, callers should always inset or outset directly from the
+   * original value coming from style.
+   */
+  static void InsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets);
+  static void OutsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets);
+
+  /**
+   * Fill in border radii for this frame.  Return whether any are nonzero.
+   * Indices into aRadii are the NS_CORNER_* constants in nsStyleConsts.h
+   * aSkipSides is a union of SIDE_BIT_LEFT/RIGHT/TOP/BOTTOM bits that says
+   * which side(s) to skip.
+   */
+  virtual bool GetBorderRadii(const nsSize& aFrameSize,
+                              const nsSize& aBorderArea,
+                              Sides aSkipSides,
+                              nscoord aRadii[8]) const;
+  bool GetBorderRadii(nscoord aRadii[8]) const;
+
+  bool GetPaddingBoxBorderRadii(nscoord aRadii[8]) const;
+  bool GetContentBoxBorderRadii(nscoord aRadii[8]) const;
+
+  /**
+   * XXX: this method will likely be replaced by GetVerticalAlignBaseline
+   * Get the position of the frame's baseline, relative to the top of
+   * the frame (its top border edge).  Only valid when Reflow is not
+   * needed.
+   * @note You should only call this on frames with a WM that's parallel to aWM.
+   * @param aWM the writing-mode of the alignment context, with the ltr/rtl
+   * direction tweak done by nsIFrame::GetWritingMode(nsIFrame*) in inline
+   * contexts (see that method).
+   */
+  virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWM) const = 0;
+
+  /**
+   * Synthesize a first(last) inline-axis baseline from our margin-box.
+   * An alphabetical baseline is at the start(end) edge and a central baseline
+   * is at the center of our block-axis margin-box (aWM tells which to use).
+   * https://drafts.csswg.org/css-align-3/#synthesize-baselines
+   * @note You should only call this on frames with a WM that's parallel to aWM.
+   * @param aWM the writing-mode of the alignment context
+   * @return an offset from our border-box block-axis start(end) edge for
+   * a first(last) baseline respectively
+   * (implemented in nsIFrameInlines.h)
+   */
+  inline nscoord SynthesizeBaselineBOffsetFromMarginBox(
+                   mozilla::WritingMode aWM,
+                   BaselineSharingGroup aGroup) const;
+
+  /**
+   * Synthesize a first(last) inline-axis baseline from our border-box.
+   * An alphabetical baseline is at the start(end) edge and a central baseline
+   * is at the center of our block-axis border-box (aWM tells which to use).
+   * https://drafts.csswg.org/css-align-3/#synthesize-baselines
+   * @note The returned value is only valid when reflow is not needed.
+   * @note You should only call this on frames with a WM that's parallel to aWM.
+   * @param aWM the writing-mode of the alignment context
+   * @return an offset from our border-box block-axis start(end) edge for
+   * a first(last) baseline respectively
+   * (implemented in nsIFrameInlines.h)
+   */
+  inline nscoord SynthesizeBaselineBOffsetFromBorderBox(
+                   mozilla::WritingMode aWM,
+                   BaselineSharingGroup aGroup) const;
+
+  /**
+   * Return the position of the frame's inline-axis baseline, or synthesize one
+   * for the given alignment context. The returned baseline is the distance from
+   * the block-axis border-box start(end) edge for aBaselineGroup eFirst(eLast).
+   * @note The returned value is only valid when reflow is not needed.
+   * @note You should only call this on frames with a WM that's parallel to aWM.
+   * @param aWM the writing-mode of the alignment context
+   * @param aBaselineOffset out-param, only valid if the method returns true
+   * (implemented in nsIFrameInlines.h)
+   */
+  inline nscoord BaselineBOffset(mozilla::WritingMode aWM,
+                                 BaselineSharingGroup aBaselineGroup,
+                                 AlignmentContext     aAlignmentContext) const;
+
+  /**
+   * XXX: this method is taking over the role that GetLogicalBaseline has.
+   * Return true if the frame has a CSS2 'vertical-align' baseline.
+   * If it has, then the returned baseline is the distance from the block-
+   * axis border-box start edge.
+   * @note This method should only be used in AlignmentContext::eInline contexts.
+   * @note The returned value is only valid when reflow is not needed.
+   * @note You should only call this on frames with a WM that's parallel to aWM.
+   * @param aWM the writing-mode of the alignment context
+   * @param aBaseline the baseline offset, only valid if the method returns true
+   */
+  virtual bool GetVerticalAlignBaseline(mozilla::WritingMode aWM,
+                                        nscoord* aBaseline) const {
+    return false;
+  }
+
+  /**
+   * Return true if the frame has a first(last) inline-axis natural baseline per
+   * CSS Box Alignment.  If so, then the returned baseline is the distance from
+   * the block-axis border-box start(end) edge for aBaselineGroup eFirst(eLast).
+   * https://drafts.csswg.org/css-align-3/#natural-baseline
+   * @note The returned value is only valid when reflow is not needed.
+   * @note You should only call this on frames with a WM that's parallel to aWM.
+   * @param aWM the writing-mode of the alignment context
+   * @param aBaseline the baseline offset, only valid if the method returns true
+   */
+  virtual bool GetNaturalBaselineBOffset(mozilla::WritingMode aWM,
+                                         BaselineSharingGroup aBaselineGroup,
+                                         nscoord*             aBaseline) const {
+    return false;
+  }
+
+  /**
+   * Get the position of the baseline on which the caret needs to be placed,
+   * relative to the top of the frame.  This is mostly needed for frames
+   * which return a baseline from GetBaseline which is not useful for
+   * caret positioning.
+   */
+  virtual nscoord GetCaretBaseline() const {
+    return GetLogicalBaseline(GetWritingMode());
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // The public visibility API.
+  ///////////////////////////////////////////////////////////////////////////////
+
+  /// @return true if we're tracking visibility for this frame.
+  bool TrackingVisibility() const
+  {
+    return bool(GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED);
+  }
+
+  /// @return the visibility state of this frame. See the Visibility enum
+  /// for the possible return values and their meanings.
+  Visibility GetVisibility() const;
+
+  /// Update the visibility state of this frame synchronously.
+  /// XXX(seth): Avoid using this method; we should be relying on the refresh
+  /// driver for visibility updates. This method, which replaces
+  /// nsLayoutUtils::UpdateApproximateFrameVisibility(), exists purely as a
+  /// temporary measure to avoid changing behavior during the transition from
+  /// the old image visibility code.
+  void UpdateVisibilitySynchronously();
+
+  // A frame property which stores the visibility state of this frame. Right
+  // now that consists of an approximate visibility counter represented as a
+  // uint32_t. When the visibility of this frame is not being tracked, this
+  // property is absent.
+  NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(VisibilityStateProperty, uint32_t);
+
+protected:
+
+  /**
+   * Subclasses can call this method to enable visibility tracking for this frame.
+   *
+   * If visibility tracking was previously disabled, this will schedule an
+   * update an asynchronous update of visibility.
+   */
+  void EnableVisibilityTracking();
+
+  /**
+   * Subclasses can call this method to disable visibility tracking for this frame.
+   *
+   * Note that if visibility tracking was previously enabled, disabling visibility
+   * tracking will cause a synchronous call to OnVisibilityChange().
+   */
+  void DisableVisibilityTracking();
+
+  /**
+   * Called when a frame transitions between visibility states (for example,
+   * from nonvisible to visible, or from visible to nonvisible).
+   *
+   * @param aNewVisibility    The new visibility state.
+   * @param aNonvisibleAction A requested action if the frame has become
+   *                          nonvisible. If Nothing(), no action is
+   *                          requested. If DISCARD_IMAGES is specified, the
+   *                          frame is requested to ask any images it's
+   *                          associated with to discard their surfaces if
+   *                          possible.
+   *
+   * Subclasses which override this method should call their parent class's
+   * implementation.
+   */
+  virtual void OnVisibilityChange(Visibility aNewVisibility,
+                                  Maybe<OnNonvisible> aNonvisibleAction = Nothing());
+
+public:
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Internal implementation for the approximate frame visibility API.
+  ///////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * We track the approximate visibility of frames using a counter; if it's
+   * non-zero, then the frame is considered visible. Using a counter allows us
+   * to account for situations where the frame may be visible in more than one
+   * place (for example, via -moz-element), and it simplifies the
+   * implementation of our approximate visibility tracking algorithms.
+   *
+   * @param aNonvisibleAction A requested action if the frame has become
+   *                          nonvisible. If Nothing(), no action is
+   *                          requested. If DISCARD_IMAGES is specified, the
+   *                          frame is requested to ask any images it's
+   *                          associated with to discard their surfaces if
+   *                          possible.
+   */
+  void DecApproximateVisibleCount(Maybe<OnNonvisible> aNonvisibleAction = Nothing());
+  void IncApproximateVisibleCount();
+
+
+  /**
+   * Get the specified child list.
+   *
+   * @param   aListID identifies the requested child list.
+   * @return  the child list.  If the requested list is unsupported by this
+   *          frame type, an empty list will be returned.
+   */
+  virtual const nsFrameList& GetChildList(ChildListID aListID) const = 0;
+  const nsFrameList& PrincipalChildList() const { return GetChildList(kPrincipalList); }
+  virtual void GetChildLists(nsTArray<ChildList>* aLists) const = 0;
+
+  /**
+   * Gets the child lists for this frame, including
+   * ones belong to a child document.
+   */
+  void GetCrossDocChildLists(nsTArray<ChildList>* aLists);
+
+  // The individual concrete child lists.
+  static const ChildListID kPrincipalList = mozilla::layout::kPrincipalList;
+  static const ChildListID kAbsoluteList = mozilla::layout::kAbsoluteList;
+  static const ChildListID kBulletList = mozilla::layout::kBulletList;
+  static const ChildListID kCaptionList = mozilla::layout::kCaptionList;
+  static const ChildListID kColGroupList = mozilla::layout::kColGroupList;
+  static const ChildListID kExcessOverflowContainersList = mozilla::layout::kExcessOverflowContainersList;
+  static const ChildListID kFixedList = mozilla::layout::kFixedList;
+  static const ChildListID kFloatList = mozilla::layout::kFloatList;
+  static const ChildListID kOverflowContainersList = mozilla::layout::kOverflowContainersList;
+  static const ChildListID kOverflowList = mozilla::layout::kOverflowList;
+  static const ChildListID kOverflowOutOfFlowList = mozilla::layout::kOverflowOutOfFlowList;
+  static const ChildListID kPopupList = mozilla::layout::kPopupList;
+  static const ChildListID kPushedFloatsList = mozilla::layout::kPushedFloatsList;
+  static const ChildListID kSelectPopupList = mozilla::layout::kSelectPopupList;
+  static const ChildListID kBackdropList = mozilla::layout::kBackdropList;
+  // A special alias for kPrincipalList that do not request reflow.
+  static const ChildListID kNoReflowPrincipalList = mozilla::layout::kNoReflowPrincipalList;
+
+  /**
+   * Child frames are linked together in a doubly-linked list
+   */
+  nsIFrame* GetNextSibling() const { return mNextSibling; }
+  void SetNextSibling(nsIFrame* aNextSibling) {
+    NS_ASSERTION(this != aNextSibling, "Creating a circular frame list, this is very bad.");
+    if (mNextSibling && mNextSibling->GetPrevSibling() == this) {
+      mNextSibling->mPrevSibling = nullptr;
+    }
+    mNextSibling = aNextSibling;
+    if (mNextSibling) {
+      mNextSibling->mPrevSibling = this;
+    }
+  }
+
+  nsIFrame* GetPrevSibling() const { return mPrevSibling; }
+
+  /**
+   * Builds the display lists for the content represented by this frame
+   * and its descendants. The background+borders of this element must
+   * be added first, before any other content.
+   * 
+   * This should only be called by methods in nsFrame. Instead of calling this
+   * directly, call either BuildDisplayListForStackingContext or
+   * BuildDisplayListForChild.
+   * 
+   * See nsDisplayList.h for more information about display lists.
+   * 
+   * @param aDirtyRect content outside this rectangle can be ignored; the
+   * rectangle is in frame coordinates
+   */
+  virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                                const nsRect&           aDirtyRect,
+                                const nsDisplayListSet& aLists) {}
+  /**
+   * Displays the caret onto the given display list builder. The caret is
+   * painted on top of the rest of the display list items.
+   *
+   * @param aDirtyRect is the dirty rectangle that we're repainting.
+   */
+  void DisplayCaret(nsDisplayListBuilder* aBuilder,
+                    const nsRect&         aDirtyRect,
+                    nsDisplayList*        aList);
+
+  /**
+   * Get the preferred caret color at the offset.
+   *
+   * @param aOffset is offset of the content.
+   */
+  virtual nscolor GetCaretColorAt(int32_t aOffset);
+
+ 
+  bool IsThemed(nsITheme::Transparency* aTransparencyState = nullptr) const {
+    return IsThemed(StyleDisplay(), aTransparencyState);
+  }
+  bool IsThemed(const nsStyleDisplay* aDisp,
+                  nsITheme::Transparency* aTransparencyState = nullptr) const {
+    nsIFrame* mutable_this = const_cast<nsIFrame*>(this);
+    if (!aDisp->mAppearance)
+      return false;
+    nsPresContext* pc = PresContext();
+    nsITheme *theme = pc->GetTheme();
+    if(!theme ||
+       !theme->ThemeSupportsWidget(pc, mutable_this, aDisp->mAppearance))
+      return false;
+    if (aTransparencyState) {
+      *aTransparencyState =
+        theme->GetWidgetTransparency(mutable_this, aDisp->mAppearance);
+    }
+    return true;
+  }
+  
+  /**
+   * Builds a display list for the content represented by this frame,
+   * treating this frame as the root of a stacking context.
+   * @param aDirtyRect content outside this rectangle can be ignored; the
+   * rectangle is in frame coordinates
+   */
+  void BuildDisplayListForStackingContext(nsDisplayListBuilder* aBuilder,
+                                          const nsRect&         aDirtyRect,
+                                          nsDisplayList*        aList);
+
+  enum {
+    DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT = 0x01,
+    DISPLAY_CHILD_FORCE_STACKING_CONTEXT = 0x02,
+    DISPLAY_CHILD_INLINE = 0x04
+  };
+  /**
+   * Adjusts aDirtyRect for the child's offset, checks that the dirty rect
+   * actually intersects the child (or its descendants), calls BuildDisplayList
+   * on the child if necessary, and puts things in the right lists if the child
+   * is positioned.
+   *
+   * @param aFlags combination of DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT,
+   *    DISPLAY_CHILD_FORCE_STACKING_CONTEXT and DISPLAY_CHILD_INLINE
+   */
+  void BuildDisplayListForChild(nsDisplayListBuilder*   aBuilder,
+                                nsIFrame*               aChild,
+                                const nsRect&           aDirtyRect,
+                                const nsDisplayListSet& aLists,
+                                uint32_t                aFlags = 0);
+
+  /**
+   * Does this frame need a view?
+   */
+  virtual bool NeedsView() { return false; }
+
+  bool RefusedAsyncAnimation() const
+  {
+    return Properties().Get(RefusedAsyncAnimationProperty());
+  }
+
+  /**
+   * Returns true if this frame is transformed (e.g. has CSS or SVG transforms)
+   * or if its parent is an SVG frame that has children-only transforms (e.g.
+   * an SVG viewBox attribute) or if its transform-style is preserve-3d or
+   * the frame has transform animations.
+   */
+  bool IsTransformed() const;
+
+  /**
+   * Returns true if the frame is translucent or the frame has opacity
+   * animations for the purposes of creating a stacking context.
+   */
+  bool HasOpacity() const
+  {
+    return HasOpacityInternal(1.0f);
+  }
+  /**
+   * Returns true if the frame is translucent for display purposes.
+   */
+  bool HasVisualOpacity() const
+  {
+    // Treat an opacity value of 0.99 and above as opaque.  This is an
+    // optimization aimed at Web content which use opacity:0.99 as a hint for
+    // creating a stacking context only.
+    return HasOpacityInternal(0.99f);
+  }
+
+   /**
+   * Return true if this frame might be using a transform getter.
+   */
+  virtual bool HasTransformGetter() const { return false; }
+
+  /**
+   * Returns true if this frame is an SVG frame that has SVG transforms applied
+   * to it, or if its parent frame is an SVG frame that has children-only
+   * transforms (e.g. an SVG viewBox attribute).
+   * If aOwnTransforms is non-null and the frame has its own SVG transforms,
+   * aOwnTransforms will be set to these transforms. If aFromParentTransforms
+   * is non-null and the frame has an SVG parent with children-only transforms,
+   * then aFromParentTransforms will be set to these transforms.
+   */
+  virtual bool IsSVGTransformed(Matrix *aOwnTransforms = nullptr,
+                                Matrix *aFromParentTransforms = nullptr) const;
+
+  /**
+   * Returns whether this frame will attempt to extend the 3d transforms of its
+   * children. This requires transform-style: preserve-3d, as well as no clipping
+   * or svg effects.
+   */
+  bool Extend3DContext() const;
+
+  /**
+   * Returns whether this frame has a parent that Extend3DContext() and has
+   * its own transform (or hidden backface) to be combined with the parent's
+   * transform.
+   */
+  bool Combines3DTransformWithAncestors() const;
+
+  /**
+   * Returns whether this frame has a hidden backface and has a parent that
+   * Extend3DContext(). This is useful because in some cases the hidden
+   * backface can safely be ignored if it could not be visible anyway.
+   */
+  bool In3DContextAndBackfaceIsHidden() const;
+
+  bool IsPreserve3DLeaf() const {
+    return Combines3DTransformWithAncestors() && !Extend3DContext();
+  }
+
+  bool HasPerspective() const;
+
+  bool ChildrenHavePerspective() const;
+
+  /**
+   * Includes the overflow area of all descendants that participate in the current
+   * 3d context into aOverflowAreas.
+   */
+  void ComputePreserve3DChildrenOverflow(nsOverflowAreas& aOverflowAreas);
+
+  void RecomputePerspectiveChildrenOverflow(const nsIFrame* aStartFrame);
+
+  /**
+   * Returns the number of ancestors between this and the root of our frame tree
+   */
+  uint32_t GetDepthInFrameTree() const;
+
+  /**
+   * Event handling of GUI events.
+   *
+   * @param   aEvent event structure describing the type of event and rge widget
+   *            where the event originated
+   *          The |point| member of this is in the coordinate system of the
+   *          view returned by GetOffsetFromView.
+   * @param   aEventStatus a return value indicating whether the event was handled
+   *            and whether default processing should be done
+   *
+   * XXX From a frame's perspective it's unclear what the effect of the event status
+   * is. Does it cause the event to continue propagating through the frame hierarchy
+   * or is it just returned to the widgets?
+   *
+   * @see     WidgetGUIEvent
+   * @see     nsEventStatus
+   */
+  virtual nsresult  HandleEvent(nsPresContext* aPresContext,
+                                mozilla::WidgetGUIEvent* aEvent,
+                                nsEventStatus* aEventStatus) = 0;
+
+  virtual nsresult  GetContentForEvent(mozilla::WidgetEvent* aEvent,
+                                       nsIContent** aContent) = 0;
+
+  // This structure keeps track of the content node and offsets associated with
+  // a point; there is a primary and a secondary offset associated with any
+  // point.  The primary and secondary offsets differ when the point is over a
+  // non-text object.  The primary offset is the expected position of the
+  // cursor calculated from a point; the secondary offset, when it is different,
+  // indicates that the point is in the boundaries of some selectable object.
+  // Note that the primary offset can be after the secondary offset; for places
+  // that need the beginning and end of the object, the StartOffset and 
+  // EndOffset helpers can be used.
+  struct MOZ_STACK_CLASS ContentOffsets
+  {
+    ContentOffsets() : offset(0)
+                     , secondaryOffset(0)
+                     , associate(mozilla::CARET_ASSOCIATE_BEFORE) {}
+    bool IsNull() { return !content; }
+    // Helpers for places that need the ends of the offsets and expect them in
+    // numerical order, as opposed to wanting the primary and secondary offsets
+    int32_t StartOffset() { return std::min(offset, secondaryOffset); }
+    int32_t EndOffset() { return std::max(offset, secondaryOffset); }
+
+    nsCOMPtr<nsIContent> content;
+    int32_t offset;
+    int32_t secondaryOffset;
+    // This value indicates whether the associated content is before or after
+    // the offset; the most visible use is to allow the caret to know which line
+    // to display on.
+    mozilla::CaretAssociationHint associate;
+  };
+  enum {
+    IGNORE_SELECTION_STYLE = 0x01,
+    // Treat visibility:hidden frames as non-selectable
+    SKIP_HIDDEN = 0x02
+  };
+  /**
+   * This function calculates the content offsets for selection relative to
+   * a point.  Note that this should generally only be callled on the event
+   * frame associated with an event because this function does not account
+   * for frame lists other than the primary one.
+   * @param aPoint point relative to this frame
+   */
+  ContentOffsets GetContentOffsetsFromPoint(nsPoint aPoint,
+                                            uint32_t aFlags = 0);
+
+  virtual ContentOffsets GetContentOffsetsFromPointExternal(nsPoint aPoint,
+                                                            uint32_t aFlags = 0)
+  { return GetContentOffsetsFromPoint(aPoint, aFlags); }
+
+  /**
+   * Ensure that aImage gets notifed when the underlying image request loads
+   * or animates.
+   */
+  void AssociateImage(const nsStyleImage& aImage, nsPresContext* aPresContext);
+
+  /**
+   * This structure holds information about a cursor. mContainer represents a
+   * loaded image that should be preferred. If it is not possible to use it, or
+   * if it is null, mCursor should be used.
+   */
+  struct MOZ_STACK_CLASS Cursor {
+    nsCOMPtr<imgIContainer> mContainer;
+    int32_t                 mCursor;
+    bool                    mHaveHotspot;
+    bool                    mLoading;
+    float                   mHotspotX, mHotspotY;
+  };
+  /**
+   * Get the cursor for a given frame.
+   */
+  virtual nsresult  GetCursor(const nsPoint&  aPoint,
+                              Cursor&         aCursor) = 0;
+
+  /**
+   * Get a point (in the frame's coordinate space) given an offset into
+   * the content. This point should be on the baseline of text with
+   * the correct horizontal offset
+   */
+  virtual nsresult  GetPointFromOffset(int32_t                  inOffset,
+                                       nsPoint*                 outPoint) = 0;
+
+  /**
+   * Get a list of character rects in a given range.
+   * This is similar version of GetPointFromOffset.
+   */
+  virtual nsresult  GetCharacterRectsInRange(int32_t aInOffset,
+                                             int32_t aLength,
+                                             nsTArray<nsRect>& aRects) = 0;
+  
+  /**
+   * Get the child frame of this frame which contains the given
+   * content offset. outChildFrame may be this frame, or nullptr on return.
+   * outContentOffset returns the content offset relative to the start
+   * of the returned node. You can also pass a hint which tells the method
+   * to stick to the end of the first found frame or the beginning of the 
+   * next in case the offset falls on a boundary.
+   */
+  virtual nsresult GetChildFrameContainingOffset(int32_t    inContentOffset,
+                                                 bool       inHint,//false stick left
+                                                 int32_t*   outFrameContentOffset,
+                                                 nsIFrame** outChildFrame) = 0;
+
+ /**
+   * Get the current frame-state value for this frame. aResult is
+   * filled in with the state bits. 
+   */
+  nsFrameState GetStateBits() const { return mState; }
+
+  /**
+   * Update the current frame-state value for this frame. 
+   */
+  void AddStateBits(nsFrameState aBits) { mState |= aBits; }
+  void RemoveStateBits(nsFrameState aBits) { mState &= ~aBits; }
+
+  /**
+   * Checks if the current frame-state includes all of the listed bits
+   */
+  bool HasAllStateBits(nsFrameState aBits) const
+  {
+    return (mState & aBits) == aBits;
+  }
+  
+  /**
+   * Checks if the current frame-state includes any of the listed bits
+   */
+  bool HasAnyStateBits(nsFrameState aBits) const
+  {
+    return mState & aBits;
+  }
+
+  /**
+   * This call is invoked on the primary frame for a character data content
+   * node, when it is changed in the content tree.
+   */
+  virtual nsresult  CharacterDataChanged(CharacterDataChangeInfo* aInfo) = 0;
+
+  /**
+   * This call is invoked when the value of a content objects's attribute
+   * is changed. 
+   * The first frame that maps that content is asked to deal
+   * with the change by doing whatever is appropriate.
+   *
+   * @param aNameSpaceID the namespace of the attribute
+   * @param aAttribute the atom name of the attribute
+   * @param aModType Whether or not the attribute was added, changed, or removed.
+   *   The constants are defined in nsIDOMMutationEvent.h.
+   */
+  virtual nsresult  AttributeChanged(int32_t         aNameSpaceID,
+                                     nsIAtom*        aAttribute,
+                                     int32_t         aModType) = 0;
+
+  /**
+   * When the content states of a content object change, this method is invoked
+   * on the primary frame of that content object.
+   *
+   * @param aStates the changed states
+   */
+  virtual void ContentStatesChanged(mozilla::EventStates aStates);
+
+  /**
+   * Return how your frame can be split.
+   */
+  virtual nsSplittableType GetSplittableType() const = 0;
+
+  /**
+   * Continuation member functions
+   */
+  virtual nsIFrame* GetPrevContinuation() const = 0;
+  virtual void SetPrevContinuation(nsIFrame*) = 0;
+  virtual nsIFrame* GetNextContinuation() const = 0;
+  virtual void SetNextContinuation(nsIFrame*) = 0;
+  virtual nsIFrame* FirstContinuation() const {
+    return const_cast<nsIFrame*>(this);
+  }
+  virtual nsIFrame* LastContinuation() const {
+    return const_cast<nsIFrame*>(this);
+  }
+
+  /**
+   * GetTailContinuation gets the last non-overflow-container continuation
+   * in the continuation chain, i.e. where the next sibling element
+   * should attach).
+   */
+  nsIFrame* GetTailContinuation();
+
+  /**
+   * Flow member functions
+   */
+  virtual nsIFrame* GetPrevInFlowVirtual() const = 0;
+  nsIFrame* GetPrevInFlow() const { return GetPrevInFlowVirtual(); }
+  virtual void SetPrevInFlow(nsIFrame*) = 0;
+
+  virtual nsIFrame* GetNextInFlowVirtual() const = 0;
+  nsIFrame* GetNextInFlow() const { return GetNextInFlowVirtual(); }
+  virtual void SetNextInFlow(nsIFrame*) = 0;
+
+  /**
+   * Return the first frame in our current flow. 
+   */
+  virtual nsIFrame* FirstInFlow() const {
+    return const_cast<nsIFrame*>(this);
+  }
+
+  /**
+   * Return the last frame in our current flow.
+   */
+  virtual nsIFrame* LastInFlow() const {
+    return const_cast<nsIFrame*>(this);
+  }
+
+  /**
+   * Note: "width" in the names and comments on the following methods
+   * means inline-size, which could be height in vertical layout
+   */
+
+  /**
+   * Mark any stored intrinsic width information as dirty (requiring
+   * re-calculation).  Note that this should generally not be called
+   * directly; nsPresShell::FrameNeedsReflow will call it instead.
+   */
+  virtual void MarkIntrinsicISizesDirty() = 0;
+
+  /**
+   * Get the min-content intrinsic inline size of the frame.  This must be
+   * less than or equal to the max-content intrinsic inline size.
+   *
+   * This is *not* affected by the CSS 'min-width', 'width', and
+   * 'max-width' properties on this frame, but it is affected by the
+   * values of those properties on this frame's descendants.  (It may be
+   * called during computation of the values of those properties, so it
+   * cannot depend on any values in the nsStylePosition for this frame.)
+   *
+   * The value returned should **NOT** include the space required for
+   * padding and border.
+   *
+   * Note that many frames will cache the result of this function call
+   * unless MarkIntrinsicISizesDirty is called.
+   *
+   * It is not acceptable for a frame to mark itself dirty when this
+   * method is called.
+   *
+   * This method must not return a negative value.
+   */
+  virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) = 0;
+
+  /**
+   * Get the max-content intrinsic inline size of the frame.  This must be
+   * greater than or equal to the min-content intrinsic inline size.
+   *
+   * Otherwise, all the comments for |GetMinISize| above apply.
+   */
+  virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) = 0;
+
+  /**
+   * |InlineIntrinsicISize| represents the intrinsic width information
+   * in inline layout.  Code that determines the intrinsic width of a
+   * region of inline layout accumulates the result into this structure.
+   * This pattern is needed because we need to maintain state
+   * information about whitespace (for both collapsing and trimming).
+   */
+  struct InlineIntrinsicISizeData {
+    InlineIntrinsicISizeData()
+      : mLine(nullptr)
+      , mLineContainer(nullptr)
+      , mPrevLines(0)
+      , mCurrentLine(0)
+      , mTrailingWhitespace(0)
+      , mSkipWhitespace(true)
+    {}
+
+    // The line. This may be null if the inlines are not associated with
+    // a block or if we just don't know the line.
+    const nsLineList_iterator* mLine;
+
+    // The line container. Private, to ensure we always use SetLineContainer
+    // to update it (so that we have a chance to store the mLineContainerWM).
+    //
+    // Note that nsContainerFrame::DoInlineIntrinsicISize will clear the
+    // |mLine| and |mLineContainer| fields when following a next-in-flow link,
+    // so we must not assume these can always be dereferenced.
+  private:
+    nsIFrame* mLineContainer;
+
+    // Setter and getter for the lineContainer field:
+  public:
+    void SetLineContainer(nsIFrame* aLineContainer)
+    {
+      mLineContainer = aLineContainer;
+      if (mLineContainer) {
+        mLineContainerWM = mLineContainer->GetWritingMode();
+      }
+    }
+    nsIFrame* LineContainer() const { return mLineContainer; }
+
+    // The maximum intrinsic width for all previous lines.
+    nscoord mPrevLines;
+
+    // The maximum intrinsic width for the current line.  At a line
+    // break (mandatory for preferred width; allowed for minimum width),
+    // the caller should call |Break()|.
+    nscoord mCurrentLine;
+
+    // This contains the width of the trimmable whitespace at the end of
+    // |mCurrentLine|; it is zero if there is no such whitespace.
+    nscoord mTrailingWhitespace;
+
+    // True if initial collapsable whitespace should be skipped.  This
+    // should be true at the beginning of a block, after hard breaks
+    // and when the last text ended with whitespace.
+    bool mSkipWhitespace;
+
+    // Writing mode of the line container (stored here so that we don't
+    // lose track of it if the mLineContainer field is reset).
+    mozilla::WritingMode mLineContainerWM;
+
+    // Floats encountered in the lines.
+    class FloatInfo {
+    public:
+      FloatInfo(const nsIFrame* aFrame, nscoord aWidth)
+        : mFrame(aFrame), mWidth(aWidth)
+      { }
+      const nsIFrame* Frame() const { return mFrame; }
+      nscoord         Width() const { return mWidth; }
+
+    private:
+      const nsIFrame* mFrame;
+      nscoord         mWidth;
+    };
+
+    nsTArray<FloatInfo> mFloats;
+  };
+
+  struct InlineMinISizeData : public InlineIntrinsicISizeData {
+    InlineMinISizeData()
+      : mAtStartOfLine(true)
+    {}
+
+    // The default implementation for nsIFrame::AddInlineMinISize.
+    void DefaultAddInlineMinISize(nsIFrame* aFrame,
+                                  nscoord   aISize,
+                                  bool      aAllowBreak = true);
+
+    // We need to distinguish forced and optional breaks for cases where the
+    // current line total is negative.  When it is, we need to ignore
+    // optional breaks to prevent min-width from ending up bigger than
+    // pref-width.
+    void ForceBreak();
+
+    // If the break here is actually taken, aHyphenWidth must be added to the
+    // width of the current line.
+    void OptionallyBreak(nscoord aHyphenWidth = 0);
+
+    // Whether we're currently at the start of the line.  If we are, we
+    // can't break (for example, between the text-indent and the first
+    // word).
+    bool mAtStartOfLine;
+  };
+
+  struct InlinePrefISizeData : public InlineIntrinsicISizeData {
+    void ForceBreak();
+
+    // The default implementation for nsIFrame::AddInlinePrefISize.
+    void DefaultAddInlinePrefISize(nscoord aISize);
+  };
+
+  /**
+   * Add the intrinsic minimum width of a frame in a way suitable for
+   * use in inline layout to an |InlineIntrinsicISizeData| object that
+   * represents the intrinsic width information of all the previous
+   * frames in the inline layout region.
+   *
+   * All *allowed* breakpoints within the frame determine what counts as
+   * a line for the |InlineIntrinsicISizeData|.  This means that
+   * |aData->mTrailingWhitespace| will always be zero (unlike for
+   * AddInlinePrefISize).
+   *
+   * All the comments for |GetMinISize| apply, except that this function
+   * is responsible for adding padding, border, and margin and for
+   * considering the effects of 'width', 'min-width', and 'max-width'.
+   *
+   * This may be called on any frame.  Frames that do not participate in
+   * line breaking can inherit the default implementation on nsFrame,
+   * which calls |GetMinISize|.
+   */
+  virtual void
+  AddInlineMinISize(nsRenderingContext *aRenderingContext,
+                    InlineMinISizeData *aData) = 0;
+
+  /**
+   * Add the intrinsic preferred width of a frame in a way suitable for
+   * use in inline layout to an |InlineIntrinsicISizeData| object that
+   * represents the intrinsic width information of all the previous
+   * frames in the inline layout region.
+   *
+   * All the comments for |AddInlineMinISize| and |GetPrefISize| apply,
+   * except that this fills in an |InlineIntrinsicISizeData| structure
+   * based on using all *mandatory* breakpoints within the frame.
+   */
+  virtual void
+  AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+                     InlinePrefISizeData *aData) = 0;
+
+  /**
+   * Return the horizontal components of padding, border, and margin
+   * that contribute to the intrinsic width that applies to the parent.
+   */
+  struct IntrinsicISizeOffsetData {
+    nscoord hPadding, hBorder, hMargin;
+    float hPctPadding, hPctMargin;
+
+    IntrinsicISizeOffsetData()
+      : hPadding(0), hBorder(0), hMargin(0)
+      , hPctPadding(0.0f), hPctMargin(0.0f)
+    {}
+  };
+  virtual IntrinsicISizeOffsetData IntrinsicISizeOffsets() = 0;
+
+  /**
+   * Return the bsize components of padding, border, and margin
+   * that contribute to the intrinsic width that applies to the parent.
+   */
+  IntrinsicISizeOffsetData IntrinsicBSizeOffsets();
+
+  virtual mozilla::IntrinsicSize GetIntrinsicSize() = 0;
+
+  /**
+   * Get the intrinsic ratio of this element, or nsSize(0,0) if it has
+   * no intrinsic ratio.  The intrinsic ratio is the ratio of the
+   * height/width of a box with an intrinsic size or the intrinsic
+   * aspect ratio of a scalable vector image without an intrinsic size.
+   *
+   * Either one of the sides may be zero, indicating a zero or infinite
+   * ratio.
+   */
+  virtual nsSize GetIntrinsicRatio() = 0;
+
+  /**
+   * Bit-flags to pass to ComputeSize in |aFlags| parameter.
+   */
+  enum ComputeSizeFlags {
+    eDefault =           0,
+    /**
+     * Set if the frame is in a context where non-replaced blocks should
+     * shrink-wrap (e.g., it's floating, absolutely positioned, or
+     * inline-block).
+     */
+    eShrinkWrap =        1 << 0,
+    /**
+     * Set if we'd like to compute our 'auto' bsize, regardless of our actual
+     * corresponding computed value. (e.g. to get an intrinsic height for flex
+     * items with "min-height: auto" to use during flexbox layout.)
+     */
+    eUseAutoBSize =      1 << 1,
+    /**
+     * Indicates that we should clamp the margin-box min-size to the given CB
+     * size.  This is used for implementing the grid area clamping here:
+     * https://drafts.csswg.org/css-grid/#min-size-auto
+     */
+    eIClampMarginBoxMinSize = 1 << 2, // clamp in our inline axis
+    eBClampMarginBoxMinSize = 1 << 3, // clamp in our block axis
+  };
+
+  /**
+   * Compute the size that a frame will occupy.  Called while
+   * constructing the ReflowInput to be used to Reflow the frame,
+   * in order to fill its mComputedWidth and mComputedHeight member
+   * variables.
+   *
+   * The |height| member of the return value may be
+   * NS_UNCONSTRAINEDSIZE, but the |width| member must not be.
+   *
+   * Note that the reason that border and padding need to be passed
+   * separately is so that the 'box-sizing' property can be handled.
+   * Thus aMargin includes absolute positioning offsets as well.
+   *
+   * @param aWritingMode  The writing mode to use for the returned size
+   *                      (need not match this frame's writing mode).
+   *                      This is also the writing mode of the passed-in
+   *                      LogicalSize parameters.
+   * @param aCBSize  The size of the element's containing block.  (Well,
+   *                 the |height| component isn't really.)
+   * @param aAvailableWidth  The available width for 'auto' widths.
+   *                         This is usually the same as aCBSize.width,
+   *                         but differs in cases such as block
+   *                         formatting context roots next to floats, or
+   *                         in some cases of float reflow in quirks
+   *                         mode.
+   * @param aMargin  The sum of the vertical / horizontal margins
+   *                 ***AND*** absolute positioning offsets (top, right,
+   *                 bottom, left) of the frame, including actual values
+   *                 resulting from percentages and from the
+   *                 "hypothetical box" for absolute positioning, but
+   *                 not including actual values resulting from 'auto'
+   *                 margins or ignored 'auto' values in absolute
+   *                 positioning.
+   * @param aBorder  The sum of the vertical / horizontal border widths
+   *                 of the frame.
+   * @param aPadding The sum of the vertical / horizontal margins of
+   *                 the frame, including actual values resulting from
+   *                 percentages.
+   * @param aFlags   Flags to further customize behavior (definitions above).
+   */
+  virtual mozilla::LogicalSize
+  ComputeSize(nsRenderingContext *aRenderingContext,
+              mozilla::WritingMode aWritingMode,
+              const mozilla::LogicalSize& aCBSize,
+              nscoord aAvailableISize,
+              const mozilla::LogicalSize& aMargin,
+              const mozilla::LogicalSize& aBorder,
+              const mozilla::LogicalSize& aPadding,
+              ComputeSizeFlags aFlags) = 0;
+
+  /**
+   * Compute a tight bounding rectangle for the frame. This is a rectangle
+   * that encloses the pixels that are actually drawn. We're allowed to be
+   * conservative and currently we don't try very hard. The rectangle is
+   * in appunits and relative to the origin of this frame.
+   *
+   * This probably only needs to include frame bounds, glyph bounds, and
+   * text decorations, but today it sometimes includes other things that
+   * contribute to visual overflow.
+   *
+   * @param aDrawTarget a draw target that can be used if we need
+   * to do measurement
+   */
+  virtual nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const;
+
+  /**
+   * This function is similar to GetPrefISize and ComputeTightBounds: it
+   * computes the left and right coordinates of a preferred tight bounding
+   * rectangle for the frame. This is a rectangle that would enclose the pixels
+   * that are drawn if we lay out the element without taking any optional line
+   * breaks. The rectangle is in appunits and relative to the origin of this
+   * frame. Currently, this function is only implemented for nsBlockFrame and
+   * nsTextFrame and is used to determine intrinsic widths of MathML token
+   * elements.
+
+   * @param aContext a rendering context that can be used if we need
+   * to do measurement
+   * @param aX      computed left coordinate of the tight bounding rectangle
+   * @param aXMost  computed intrinsic width of the tight bounding rectangle
+   *
+   */
+  virtual nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext,
+                                           nscoord* aX,
+                                           nscoord* aXMost);
+
+  /**
+   * The frame is given an available size and asked for its desired
+   * size.  This is the frame's opportunity to reflow its children.
+   *
+   * If the frame has the NS_FRAME_IS_DIRTY bit set then it is
+   * responsible for completely reflowing itself and all of its
+   * descendants.
+   *
+   * Otherwise, if the frame has the NS_FRAME_HAS_DIRTY_CHILDREN bit
+   * set, then it is responsible for reflowing at least those
+   * children that have NS_FRAME_HAS_DIRTY_CHILDREN or NS_FRAME_IS_DIRTY
+   * set.
+   *
+   * If a difference in available size from the previous reflow causes
+   * the frame's size to change, it should reflow descendants as needed.
+   *
+   * @param aReflowOutput <i>out</i> parameter where you should return the
+   *          desired size and ascent/descent info. You should include any
+   *          space you want for border/padding in the desired size you return.
+   *
+   *          It's okay to return a desired size that exceeds the avail
+   *          size if that's the smallest you can be, i.e. it's your
+   *          minimum size.
+   *
+   *          For an incremental reflow you are responsible for invalidating
+   *          any area within your frame that needs repainting (including
+   *          borders). If your new desired size is different than your current
+   *          size, then your parent frame is responsible for making sure that
+   *          the difference between the two rects is repainted
+   *
+   * @param aReflowInput information about your reflow including the reason
+   *          for the reflow and the available space in which to lay out. Each
+   *          dimension of the available space can either be constrained or
+   *          unconstrained (a value of NS_UNCONSTRAINEDSIZE).
+   *
+   *          Note that the available space can be negative. In this case you
+   *          still must return an accurate desired size. If you're a container
+   *          you must <b>always</b> reflow at least one frame regardless of the
+   *          available space
+   *
+   * @param aStatus a return value indicating whether the frame is complete
+   *          and whether the next-in-flow is dirty and needs to be reflowed
+   */
+  virtual void Reflow(nsPresContext*           aPresContext,
+                      ReflowOutput&     aReflowOutput,
+                      const ReflowInput& aReflowInput,
+                      nsReflowStatus&          aStatus) = 0;
+
+  /**
+   * Post-reflow hook. After a frame is reflowed this method will be called
+   * informing the frame that this reflow process is complete, and telling the
+   * frame the status returned by the Reflow member function.
+   *
+   * This call may be invoked many times, while NS_FRAME_IN_REFLOW is set, before
+   * it is finally called once with a NS_FRAME_REFLOW_COMPLETE value. When called
+   * with a NS_FRAME_REFLOW_COMPLETE value the NS_FRAME_IN_REFLOW bit in the
+   * frame state will be cleared.
+   *
+   * XXX This doesn't make sense. If the frame is reflowed but not complete, then
+   * the status should be NS_FRAME_NOT_COMPLETE and not NS_FRAME_COMPLETE
+   * XXX Don't we want the semantics to dictate that we only call this once for
+   * a given reflow?
+   */
+  virtual void DidReflow(nsPresContext*           aPresContext,
+                         const ReflowInput* aReflowInput,
+                         nsDidReflowStatus        aStatus) = 0;
+
+  /**
+   * Updates the overflow areas of the frame. This can be called if an
+   * overflow area of the frame's children has changed without reflowing.
+   * @return true if either of the overflow areas for this frame have changed.
+   */
+  bool UpdateOverflow();
+
+  /**
+   * Computes any overflow area created by the frame itself (outside of the
+   * frame bounds) and includes it into aOverflowAreas.
+   *
+   * Returns false if updating overflow isn't supported for this frame.
+   * If the frame requires a reflow instead, then it is responsible
+   * for scheduling one.
+   */
+  virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) = 0;
+
+  /**
+   * Computes any overflow area created by children of this frame and
+   * includes it into aOverflowAreas.
+   */
+  virtual void UnionChildOverflow(nsOverflowAreas& aOverflowAreas) = 0;
+
+  /**
+   * Helper method used by block reflow to identify runs of text so
+   * that proper word-breaking can be done.
+   *
+   * @return 
+   *    true if we can continue a "text run" through the frame. A
+   *    text run is text that should be treated contiguously for line
+   *    and word breaking.
+   */
+  virtual bool CanContinueTextRun() const = 0;
+
+  /**
+   * Computes an approximation of the rendered text of the frame and its
+   * continuations. Returns nothing for non-text frames.
+   * The appended text will often not contain all the whitespace from source,
+   * depending on CSS white-space processing.
+   * if aEndOffset goes past end, use the text up to the string's end.
+   * Call this on the primary frame for a text node.
+   * aStartOffset and aEndOffset can be content offsets or offsets in the
+   * rendered text, depending on aOffsetType.
+   * Returns a string, as well as offsets identifying the start of the text
+   * within the rendered text for the whole node, and within the text content
+   * of the node.
+   */
+  struct RenderedText {
+    nsAutoString mString;
+    uint32_t mOffsetWithinNodeRenderedText;
+    int32_t mOffsetWithinNodeText;
+    RenderedText() : mOffsetWithinNodeRenderedText(0),
+        mOffsetWithinNodeText(0) {}
+  };
+  enum class TextOffsetType {
+    // Passed-in start and end offsets are within the content text.
+    OFFSETS_IN_CONTENT_TEXT,
+    // Passed-in start and end offsets are within the rendered text.
+    OFFSETS_IN_RENDERED_TEXT
+  };
+  enum class TrailingWhitespace {
+    TRIM_TRAILING_WHITESPACE,
+    // Spaces preceding a caret at the end of a line should not be trimmed
+    DONT_TRIM_TRAILING_WHITESPACE
+  };
+  virtual RenderedText GetRenderedText(uint32_t aStartOffset = 0,
+                                       uint32_t aEndOffset = UINT32_MAX,
+                                       TextOffsetType aOffsetType =
+                                           TextOffsetType::OFFSETS_IN_CONTENT_TEXT,
+                                       TrailingWhitespace aTrimTrailingWhitespace =
+                                           TrailingWhitespace::TRIM_TRAILING_WHITESPACE)
+  { return RenderedText(); }
+
+  /**
+   * Returns true if the frame contains any non-collapsed characters.
+   * This method is only available for text frames, and it will return false
+   * for all other frame types.
+   */
+  virtual bool HasAnyNoncollapsedCharacters()
+  { return false; }
+
+  /**
+   * Accessor functions to get/set the associated view object
+   *
+   * GetView returns non-null if and only if |HasView| returns true.
+   */
+  bool HasView() const { return !!(mState & NS_FRAME_HAS_VIEW); }
+  nsView* GetView() const;
+  nsresult SetView(nsView* aView);
+
+  /**
+   * Find the closest view (on |this| or an ancestor).
+   * If aOffset is non-null, it will be set to the offset of |this|
+   * from the returned view.
+   */
+  nsView* GetClosestView(nsPoint* aOffset = nullptr) const;
+
+  /**
+   * Find the closest ancestor (excluding |this| !) that has a view
+   */
+  nsIFrame* GetAncestorWithView() const;
+
+  /**
+   * Get the offset between the coordinate systems of |this| and aOther.
+   * Adding the return value to a point in the coordinate system of |this|
+   * will transform the point to the coordinate system of aOther.
+   *
+   * aOther must be non-null.
+   * 
+   * This function is fastest when aOther is an ancestor of |this|.
+   *
+   * This function _DOES NOT_ work across document boundaries.
+   * Use this function only when |this| and aOther are in the same document.
+   *
+   * NOTE: this actually returns the offset from aOther to |this|, but
+   * that offset is added to transform _coordinates_ from |this| to
+   * aOther.
+   */
+  nsPoint GetOffsetTo(const nsIFrame* aOther) const;
+
+  /**
+   * Get the offset between the coordinate systems of |this| and aOther
+   * expressed in appunits per dev pixel of |this|' document. Adding the return
+   * value to a point that is relative to the origin of |this| will make the
+   * point relative to the origin of aOther but in the appunits per dev pixel
+   * ratio of |this|.
+   *
+   * aOther must be non-null.
+   * 
+   * This function is fastest when aOther is an ancestor of |this|.
+   *
+   * This function works across document boundaries.
+   *
+   * Because this function may cross document boundaries that have different
+   * app units per dev pixel ratios it needs to be used very carefully.
+   *
+   * NOTE: this actually returns the offset from aOther to |this|, but
+   * that offset is added to transform _coordinates_ from |this| to
+   * aOther.
+   */
+  nsPoint GetOffsetToCrossDoc(const nsIFrame* aOther) const;
+
+  /**
+   * Like GetOffsetToCrossDoc, but the caller can specify which appunits
+   * to return the result in.
+   */
+  nsPoint GetOffsetToCrossDoc(const nsIFrame* aOther, const int32_t aAPD) const;
+
+  /**
+   * Get the screen rect of the frame in pixels.
+   * @return the pixel rect of the frame in screen coordinates.
+   */
+  nsIntRect GetScreenRect() const;
+
+  /**
+   * Get the screen rect of the frame in app units.
+   * @return the app unit rect of the frame in screen coordinates.
+   */
+  nsRect GetScreenRectInAppUnits() const;
+
+  /**
+   * Returns the offset from this frame to the closest geometric parent that
+   * has a view. Also returns the containing view or null in case of error
+   */
+  void GetOffsetFromView(nsPoint& aOffset, nsView** aView) const;
+
+  /**
+   * Returns the nearest widget containing this frame. If this frame has a
+   * view and the view has a widget, then this frame's widget is
+   * returned, otherwise this frame's geometric parent is checked
+   * recursively upwards.
+   */
+  nsIWidget* GetNearestWidget() const;
+
+  /**
+   * Same as GetNearestWidget() above but uses an outparam to return the offset
+   * of this frame to the returned widget expressed in appunits of |this| (the
+   * widget might be in a different document with a different zoom).
+   */
+  nsIWidget* GetNearestWidget(nsPoint& aOffset) const;
+
+  /**
+   * Get the "type" of the frame. May return nullptr.
+   *
+   * @see nsGkAtoms
+   */
+  virtual nsIAtom* GetType() const = 0;
+
+  /**
+   * Returns a transformation matrix that converts points in this frame's
+   * coordinate space to points in some ancestor frame's coordinate space.
+   * The frame decides which ancestor it will use as a reference point.
+   * If this frame has no ancestor, aOutAncestor will be set to null.
+   *
+   * @param aStopAtAncestor don't look further than aStopAtAncestor. If null,
+   *   all ancestors (including across documents) will be traversed.
+   * @param aOutAncestor [out] The ancestor frame the frame has chosen.  If
+   *   this frame has no ancestor, *aOutAncestor will be set to null. If
+   * this frame is not a root frame, then *aOutAncestor will be in the same
+   * document as this frame. If this frame IsTransformed(), then *aOutAncestor
+   * will be the parent frame (if not preserve-3d) or the nearest non-transformed
+   * ancestor (if preserve-3d).
+   * @return A Matrix4x4 that converts points in this frame's coordinate space
+   *   into points in aOutAncestor's coordinate space.
+   */
+  Matrix4x4 GetTransformMatrix(const nsIFrame* aStopAtAncestor,
+                               nsIFrame **aOutAncestor);
+
+  /**
+   * Bit-flags to pass to IsFrameOfType()
+   */
+  enum {
+    eMathML =                           1 << 0,
+    eSVG =                              1 << 1,
+    eSVGForeignObject =                 1 << 2,
+    eSVGContainer =                     1 << 3,
+    eSVGGeometry =                      1 << 4,
+    eSVGPaintServer =                   1 << 5,
+    eBidiInlineContainer =              1 << 6,
+    // the frame is for a replaced element, such as an image
+    eReplaced =                         1 << 7,
+    // Frame that contains a block but looks like a replaced element
+    // from the outside
+    eReplacedContainsBlock =            1 << 8,
+    // A frame that participates in inline reflow, i.e., one that
+    // requires ReflowInput::mLineLayout.
+    eLineParticipant =                  1 << 9,
+    eXULBox =                           1 << 10,
+    eCanContainOverflowContainers =     1 << 11,
+    eBlockFrame =                       1 << 12,
+    eTablePart =                        1 << 13,
+    // If this bit is set, the frame doesn't allow ignorable whitespace as
+    // children. For example, the whitespace between <table>\n<tr>\n<td>
+    // will be excluded during the construction of children. 
+    eExcludesIgnorableWhitespace =      1 << 14,
+    eSupportsCSSTransforms =            1 << 15,
+
+    // A replaced element that has replaced-element sizing
+    // characteristics (i.e., like images or iframes), as opposed to
+    // inline-block sizing characteristics (like form controls).
+    eReplacedSizing =                   1 << 16,
+
+    // These are to allow nsFrame::Init to assert that IsFrameOfType
+    // implementations all call the base class method.  They are only
+    // meaningful in DEBUG builds.
+    eDEBUGAllFrames =                   1 << 30,
+    eDEBUGNoFrames =                    1 << 31
+  };
+
+  /**
+   * API for doing a quick check if a frame is of a given
+   * type. Returns true if the frame matches ALL flags passed in.
+   *
+   * Implementations should always override with inline virtual
+   * functions that call the base class's IsFrameOfType method.
+   */
+  virtual bool IsFrameOfType(uint32_t aFlags) const
+  {
+#ifdef DEBUG
+    return !(aFlags & ~(nsIFrame::eDEBUGAllFrames | nsIFrame::eSupportsCSSTransforms));
+#else
+    return !(aFlags & ~nsIFrame::eSupportsCSSTransforms);
+#endif
+  }
+
+  /**
+   * Returns true if the frame is a block wrapper.
+   */
+  bool IsBlockWrapper() const;
+
+  /**
+   * Get this frame's CSS containing block.
+   *
+   * The algorithm is defined in
+   * http://www.w3.org/TR/CSS2/visudet.html#containing-block-details.
+   *
+   * NOTE: This is guaranteed to return a non-null pointer when invoked on any
+   * frame other than the root frame.
+   *
+   * Requires SKIP_SCROLLED_FRAME to get behaviour matching the spec, otherwise
+   * it can return anonymous inner scrolled frames. Bug 1204044 is filed for
+   * investigating whether any of the callers actually require the default
+   * behaviour.
+   */
+  enum {
+    // If the containing block is an anonymous scrolled frame, then skip over
+    // this and return the outer scroll frame.
+    SKIP_SCROLLED_FRAME = 0x01
+  };
+  nsIFrame* GetContainingBlock(uint32_t aFlags = 0) const;
+
+  /**
+   * Is this frame a containing block for floating elements?
+   * Note that very few frames are, so default to false.
+   */
+  virtual bool IsFloatContainingBlock() const { return false; }
+
+  /**
+   * Is this a leaf frame?  Frames that want the frame constructor to be able
+   * to construct kids for them should return false, all others should return
+   * true.  Note that returning true here does not mean that the frame _can't_
+   * have kids.  It could still have kids created via
+   * nsIAnonymousContentCreator.  Returning true indicates that "normal"
+   * (non-anonymous, XBL-bound, CSS generated content, etc) children should not
+   * be constructed.
+   */
+  virtual bool IsLeaf() const;
+
+  /**
+   * Marks all display items created by this frame as needing a repaint,
+   * and calls SchedulePaint() if requested and one is not already pending.
+   *
+   * This includes all display items created by this frame, including
+   * container types.
+   *
+   * @param aDisplayItemKey If specified, only issues an invalidate
+   * if this frame painted a display item of that type during the 
+   * previous paint. SVG rendering observers are always notified.
+   */
+  virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0);
+
+  /**
+   * Same as InvalidateFrame(), but only mark a fixed rect as needing
+   * repainting.
+   *
+   * @param aRect The rect to invalidate, relative to the TopLeft of the
+   * frame's border box.
+   * @param aDisplayItemKey If specified, only issues an invalidate
+   * if this frame painted a display item of that type during the 
+   * previous paint. SVG rendering observers are always notified.
+   */
+  virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0);
+  
+  /**
+   * Calls InvalidateFrame() on all frames descendant frames (including
+   * this one).
+   * 
+   * This function doesn't walk through placeholder frames to invalidate
+   * the out-of-flow frames.
+   *
+   * @param aDisplayItemKey If specified, only issues an invalidate
+   * if this frame painted a display item of that type during the 
+   * previous paint. SVG rendering observers are always notified.
+   */
+  void InvalidateFrameSubtree(uint32_t aDisplayItemKey = 0);
+
+  /**
+   * Called when a frame is about to be removed and needs to be invalidated.
+   * Normally does nothing since DLBI handles removed frames.
+   */
+  virtual void InvalidateFrameForRemoval() {}
+
+  /**
+   * When HasUserData(frame->LayerIsPrerenderedDataKey()), then the
+   * entire overflow area of this frame has been rendered in its
+   * layer(s).
+   */
+  static void* LayerIsPrerenderedDataKey() { 
+    return &sLayerIsPrerenderedDataKey;
+  }
+  static uint8_t sLayerIsPrerenderedDataKey;
+
+   /**
+   * Try to update this frame's transform without invalidating any
+   * content.  Return true iff successful.  If unsuccessful, the
+   * caller is responsible for scheduling an invalidating paint.
+   *
+   * If the result is true, aLayerResult will be filled in with the
+   * transform layer for the frame.
+   */
+  bool TryUpdateTransformOnly(Layer** aLayerResult);
+
+  /**
+   * Checks if a frame has had InvalidateFrame() called on it since the
+   * last paint.
+   *
+   * If true, then the invalid rect is returned in aRect, with an
+   * empty rect meaning all pixels drawn by this frame should be
+   * invalidated.
+   * If false, aRect is left unchanged.
+   */
+  bool IsInvalid(nsRect& aRect);
+ 
+  /**
+   * Check if any frame within the frame subtree (including this frame) 
+   * returns true for IsInvalid().
+   */
+  bool HasInvalidFrameInSubtree()
+  {
+    return HasAnyStateBits(NS_FRAME_NEEDS_PAINT | NS_FRAME_DESCENDANT_NEEDS_PAINT);
+  }
+
+  /**
+   * Removes the invalid state from the current frame and all
+   * descendant frames.
+   */
+  void ClearInvalidationStateBits();
+
+  /**
+   * Ensures that the refresh driver is running, and schedules a view 
+   * manager flush on the next tick.
+   *
+   * The view manager flush will update the layer tree, repaint any 
+   * invalid areas in the layer tree and schedule a layer tree
+   * composite operation to display the layer tree.
+   *
+   * In general it is not necessary for frames to call this when they change.
+   * For example, changes that result in a reflow will have this called for
+   * them by PresContext::DoReflow when the reflow begins. Style changes that 
+   * do not trigger a reflow should have this called for them by
+   * DoApplyRenderingChangeToTree.
+   *
+   * @param aType PAINT_COMPOSITE_ONLY : No changes have been made
+   * that require a layer tree update, so only schedule a layer
+   * tree composite.
+   * PAINT_DELAYED_COMPRESS : Schedule a paint to be executed after a delay, and
+   * put FrameLayerBuilder in 'compressed' mode that avoids short cut optimizations.
+   */
+  enum PaintType {
+    PAINT_DEFAULT = 0,
+    PAINT_COMPOSITE_ONLY,
+    PAINT_DELAYED_COMPRESS
+  };
+  void SchedulePaint(PaintType aType = PAINT_DEFAULT);
+
+  /**
+   * Checks if the layer tree includes a dedicated layer for this 
+   * frame/display item key pair, and invalidates at least aDamageRect
+   * area within that layer.
+   *
+   * If no layer is found, calls InvalidateFrame() instead.
+   *
+   * @param aDamageRect Area of the layer to invalidate.
+   * @param aFrameDamageRect If no layer is found, the area of the frame to
+   *                         invalidate. If null, the entire frame will be
+   *                         invalidated.
+   * @param aDisplayItemKey Display item type.
+   * @param aFlags UPDATE_IS_ASYNC : Will skip the invalidation
+   * if the found layer is being composited by a remote
+   * compositor.
+   * @return Layer, if found, nullptr otherwise.
+   */
+  enum {
+    UPDATE_IS_ASYNC = 1 << 0
+  };
+  Layer* InvalidateLayer(uint32_t aDisplayItemKey,
+                         const nsIntRect* aDamageRect = nullptr,
+                         const nsRect* aFrameDamageRect = nullptr,
+                         uint32_t aFlags = 0);
+
+  /**
+   * Returns a rect that encompasses everything that might be painted by
+   * this frame.  This includes this frame, all its descendant frames, this
+   * frame's outline, and descendant frames' outline, but does not include
+   * areas clipped out by the CSS "overflow" and "clip" properties.
+   *
+   * HasOverflowRects() (below) will return true when this overflow
+   * rect has been explicitly set, even if it matches mRect.
+   * XXX Note: because of a space optimization using the formula above,
+   * during reflow this function does not give accurate data if
+   * FinishAndStoreOverflow has been called but mRect hasn't yet been
+   * updated yet.  FIXME: This actually isn't true, but it should be.
+   *
+   * The visual overflow rect should NEVER be used for things that
+   * affect layout.  The scrollable overflow rect is permitted to affect
+   * layout.
+   *
+   * @return the rect relative to this frame's origin, but after
+   * CSS transforms have been applied (i.e. not really this frame's coordinate
+   * system, and may not contain the frame's border-box, e.g. if there
+   * is a CSS transform scaling it down)
+   */
+  nsRect GetVisualOverflowRect() const {
+    return GetOverflowRect(eVisualOverflow);
+  }
+
+  /**
+   * Returns a rect that encompasses the area of this frame that the
+   * user should be able to scroll to reach.  This is similar to
+   * GetVisualOverflowRect, but does not include outline or shadows, and
+   * may in the future include more margins than visual overflow does.
+   * It does not include areas clipped out by the CSS "overflow" and
+   * "clip" properties.
+   *
+   * HasOverflowRects() (below) will return true when this overflow
+   * rect has been explicitly set, even if it matches mRect.
+   * XXX Note: because of a space optimization using the formula above,
+   * during reflow this function does not give accurate data if
+   * FinishAndStoreOverflow has been called but mRect hasn't yet been
+   * updated yet.
+   *
+   * @return the rect relative to this frame's origin, but after
+   * CSS transforms have been applied (i.e. not really this frame's coordinate
+   * system, and may not contain the frame's border-box, e.g. if there
+   * is a CSS transform scaling it down)
+   */
+  nsRect GetScrollableOverflowRect() const {
+    return GetOverflowRect(eScrollableOverflow);
+  }
+
+  nsRect GetOverflowRect(nsOverflowType aType) const;
+
+  nsOverflowAreas GetOverflowAreas() const;
+
+  /**
+   * Same as GetOverflowAreas, except in this frame's coordinate
+   * system (before transforms are applied).
+   *
+   * @return the overflow areas relative to this frame, before any CSS transforms have
+   * been applied, i.e. in this frame's coordinate system
+   */
+  nsOverflowAreas GetOverflowAreasRelativeToSelf() const;
+
+  /**
+   * Same as GetScrollableOverflowRect, except relative to the parent
+   * frame.
+   *
+   * @return the rect relative to the parent frame, in the parent frame's
+   * coordinate system
+   */
+  nsRect GetScrollableOverflowRectRelativeToParent() const;
+
+  /**
+   * Same as GetScrollableOverflowRect, except in this frame's coordinate
+   * system (before transforms are applied).
+   *
+   * @return the rect relative to this frame, before any CSS transforms have
+   * been applied, i.e. in this frame's coordinate system
+   */
+  nsRect GetScrollableOverflowRectRelativeToSelf() const;
+
+  /**
+   * Like GetVisualOverflowRect, except in this frame's
+   * coordinate system (before transforms are applied).
+   *
+   * @return the rect relative to this frame, before any CSS transforms have
+   * been applied, i.e. in this frame's coordinate system
+   */
+  nsRect GetVisualOverflowRectRelativeToSelf() const;
+
+  /**
+   * Same as GetVisualOverflowRect, except relative to the parent
+   * frame.
+   *
+   * @return the rect relative to the parent frame, in the parent frame's
+   * coordinate system
+   */
+  nsRect GetVisualOverflowRectRelativeToParent() const;
+
+  /**
+   * Returns this frame's visual overflow rect as it would be before taking
+   * account of SVG effects or transforms. The rect returned is relative to
+   * this frame.
+   */
+  nsRect GetPreEffectsVisualOverflowRect() const;
+
+  /**
+   * Store the overflow area in the frame's mOverflow.mVisualDeltas
+   * fields or as a frame property in the frame manager so that it can
+   * be retrieved later without reflowing the frame. Returns true if either of
+   * the overflow areas changed.
+   */
+  bool FinishAndStoreOverflow(nsOverflowAreas& aOverflowAreas,
+                              nsSize aNewSize, nsSize* aOldSize = nullptr);
+
+  bool FinishAndStoreOverflow(ReflowOutput* aMetrics) {
+    return FinishAndStoreOverflow(aMetrics->mOverflowAreas,
+                                  nsSize(aMetrics->Width(), aMetrics->Height()));
+  }
+
+  /**
+   * Returns whether the frame has an overflow rect that is different from
+   * its border-box.
+   */
+  bool HasOverflowAreas() const {
+    return mOverflow.mType != NS_FRAME_OVERFLOW_NONE;
+  }
+
+  /**
+   * Removes any stored overflow rects (visual and scrollable) from the frame.
+   * Returns true if the overflow changed.
+   */
+  bool ClearOverflowRects();
+
+  /**
+   * Determine whether borders, padding, margins etc should NOT be applied
+   * on certain sides of the frame.
+   * @see mozilla::Sides in gfx/2d/BaseMargin.h
+   * @see mozilla::LogicalSides in layout/generic/WritingModes.h
+   *
+   * @note (See also bug 743402, comment 11) GetSkipSides() checks to see
+   *       if this frame has a previous or next continuation to determine
+   *       if a side should be skipped.
+   *       Unfortunately, this only works after reflow has been completed. In
+   *       lieu of this, during reflow, an ReflowInput parameter can be
+   *       passed in, indicating that it should be used to determine if sides
+   *       should be skipped during reflow.
+   */
+  Sides GetSkipSides(const ReflowInput* aReflowInput = nullptr) const;
+  virtual LogicalSides
+  GetLogicalSkipSides(const ReflowInput* aReflowInput = nullptr) const {
+    return LogicalSides();
+  }
+
+  /**
+   * @returns true if this frame is selected.
+   */
+  bool IsSelected() const;
+
+  /**
+   *  called to discover where this frame, or a parent frame has user-select style
+   *  applied, which affects that way that it is selected.
+   *    
+   *  @param aIsSelectable out param. Set to true if the frame can be selected
+   *                       (i.e. is not affected by user-select: none)
+   *  @param aSelectStyle  out param. Returns the type of selection style found
+   *                        (using values defined in nsStyleConsts.h).
+   */
+  virtual nsresult IsSelectable(bool* aIsSelectable,
+                            mozilla::StyleUserSelect* aSelectStyle) const = 0;
+
+  /** 
+   *  Called to retrieve the SelectionController associated with the frame.
+   *  @param aSelCon will contain the selection controller associated with
+   *  the frame.
+   */
+  virtual nsresult  GetSelectionController(nsPresContext *aPresContext, nsISelectionController **aSelCon) = 0;
+
+  /**
+   *  Call to get nsFrameSelection for this frame.
+   */
+  already_AddRefed<nsFrameSelection> GetFrameSelection();
+
+  /**
+   * GetConstFrameSelection returns an object which methods are safe to use for
+   * example in nsIFrame code.
+   */
+  const nsFrameSelection* GetConstFrameSelection() const;
+
+  /**
+   *  called to find the previous/next character, word, or line  returns the actual 
+   *  nsIFrame and the frame offset.  THIS DOES NOT CHANGE SELECTION STATE
+   *  uses frame's begin selection state to start. if no selection on this frame will 
+   *  return NS_ERROR_FAILURE
+   *  @param aPOS is defined in nsFrameSelection
+   */
+  virtual nsresult PeekOffset(nsPeekOffsetStruct *aPos);
+
+  /**
+   *  called to find the previous/next non-anonymous selectable leaf frame.
+   *  @param aDirection [in] the direction to move in (eDirPrevious or eDirNext)
+   *  @param aVisual [in] whether bidi caret behavior is visual (true) or logical (false)
+   *  @param aJumpLines [in] whether to allow jumping across line boundaries
+   *  @param aScrollViewStop [in] whether to stop when reaching a scroll frame boundary
+   *  @param aOutFrame [out] the previous/next selectable leaf frame
+   *  @param aOutOffset [out] 0 indicates that we arrived at the beginning of the output frame;
+   *                          -1 indicates that we arrived at its end.
+   *  @param aOutJumpedLine [out] whether this frame and the returned frame are on different lines
+   *  @param aOutMovedOverNonSelectableText [out] whether we jumped over a non-selectable
+   *                                              frame during the search
+   */
+  nsresult GetFrameFromDirection(nsDirection aDirection, bool aVisual,
+                                 bool aJumpLines, bool aScrollViewStop,
+                                 nsIFrame** aOutFrame, int32_t* aOutOffset,
+                                 bool* aOutJumpedLine, bool* aOutMovedOverNonSelectableText);
+
+  /**
+   *  called to see if the children of the frame are visible from indexstart to index end.
+   *  this does not change any state. returns true only if the indexes are valid and any of
+   *  the children are visible.  for textframes this index is the character index.
+   *  if aStart = aEnd result will be false
+   *  @param aStart start index of first child from 0-N (number of children)
+   *  @param aEnd   end index of last child from 0-N
+   *  @param aRecurse should this frame talk to siblings to get to the contents other children?
+   *  @param aFinished did this frame have the aEndIndex? or is there more work to do
+   *  @param _retval  return value true or false. false = range is not rendered.
+   */
+  virtual nsresult CheckVisibility(nsPresContext* aContext, int32_t aStartIndex, int32_t aEndIndex, bool aRecurse, bool *aFinished, bool *_retval)=0;
+
+  /**
+   * Called to tell a frame that one of its child frames is dirty (i.e.,
+   * has the NS_FRAME_IS_DIRTY *or* NS_FRAME_HAS_DIRTY_CHILDREN bit
+   * set).  This should always set the NS_FRAME_HAS_DIRTY_CHILDREN on
+   * the frame, and may do other work.
+   */
+  virtual void ChildIsDirty(nsIFrame* aChild) = 0;
+
+  /**
+   * Called to retrieve this frame's accessible.
+   * If this frame implements Accessibility return a valid accessible
+   * If not return NS_ERROR_NOT_IMPLEMENTED.
+   * Note: Accessible must be refcountable. Do not implement directly on your frame
+   * Use a mediatior of some kind.
+   */
+#ifdef ACCESSIBILITY
+  virtual mozilla::a11y::AccType AccessibleType() = 0;
+#endif
+
+  /**
+   * Get the frame whose style context should be the parent of this
+   * frame's style context (i.e., provide the parent style context).
+   * This frame must either be an ancestor of this frame or a child.  If
+   * this returns a child frame, then the child frame must be sure to
+   * return a grandparent or higher!  Furthermore, if a child frame is
+   * returned it must have the same GetContent() as this frame.
+   *
+   * @param aProviderFrame (out) the frame associated with the returned value
+   *     or nullptr 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.
+   */
+  virtual nsStyleContext* GetParentStyleContext(nsIFrame** aProviderFrame) const = 0;
+
+  /**
+   * Determines whether a frame is visible for painting;
+   * taking into account whether it is painting a selection or printing.
+   */
+  bool IsVisibleForPainting(nsDisplayListBuilder* aBuilder);
+  /**
+   * Determines whether a frame is visible for painting or collapsed;
+   * taking into account whether it is painting a selection or printing,
+   */
+  bool IsVisibleOrCollapsedForPainting(nsDisplayListBuilder* aBuilder);
+  /**
+   * As above, but slower because we have to recompute some stuff that
+   * aBuilder already has.
+   */
+  bool IsVisibleForPainting();
+  /**
+   * Check whether this frame is visible in the current selection. Returns
+   * true if there is no current selection.
+   */
+  bool IsVisibleInSelection(nsDisplayListBuilder* aBuilder);
+
+  /**
+   * Overridable function to determine whether this frame should be considered
+   * "in" the given non-null aSelection for visibility purposes.
+   */  
+  virtual bool IsVisibleInSelection(nsISelection* aSelection);
+
+  /**
+   * Determines whether this frame is a pseudo stacking context, looking
+   * only as style --- i.e., assuming that it's in-flow and not a replaced
+   * element and not an SVG element.
+   * XXX maybe check IsTransformed()?
+   */
+  bool IsPseudoStackingContextFromStyle();
+
+  virtual bool HonorPrintBackgroundSettings() { return true; }
+
+  /**
+   * Determine whether the frame is logically empty, which is roughly
+   * whether the layout would be the same whether or not the frame is
+   * present.  Placeholder frames should return true.  Block frames
+   * should be considered empty whenever margins collapse through them,
+   * even though those margins are relevant.  Text frames containing
+   * only whitespace that does not contribute to the height of the line
+   * should return true.
+   */
+  virtual bool IsEmpty() = 0;
+  /**
+   * Return the same as IsEmpty(). This may only be called after the frame
+   * has been reflowed and before any further style or content changes.
+   */
+  virtual bool CachedIsEmpty();
+  /**
+   * Determine whether the frame is logically empty, assuming that all
+   * its children are empty.
+   */
+  virtual bool IsSelfEmpty() = 0;
+
+  /**
+   * IsGeneratedContentFrame returns whether a frame corresponds to
+   * generated content
+   *
+   * @return whether the frame correspods to generated content
+   */
+  bool IsGeneratedContentFrame() const {
+    return (mState & NS_FRAME_GENERATED_CONTENT) != 0;
+  }
+
+  /**
+   * IsPseudoFrame returns whether a frame is a pseudo frame (eg an
+   * anonymous table-row frame created for a CSS table-cell without an
+   * enclosing table-row.
+   *
+   * @param aParentContent the content node corresponding to the parent frame
+   * @return whether the frame is a pseudo frame
+   */   
+  bool IsPseudoFrame(const nsIContent* aParentContent) {
+    return mContent == aParentContent;
+  }
+
+  FrameProperties Properties() const {
+    return FrameProperties(PresContext()->PropertyTable(), this);
+  }
+
+  /**
+   * Return true if and only if this frame obeys visibility:hidden.
+   * if it does not, then nsContainerFrame will hide its view even though
+   * this means children can't be made visible again.
+   */
+  virtual bool SupportsVisibilityHidden() { return true; }
+
+  /**
+   * Returns the clip rect set via the 'clip' property, if the 'clip' property
+   * applies to this frame; otherwise returns Nothing(). The 'clip' property
+   * applies to HTML frames if they are absolutely positioned. The 'clip'
+   * property applies to SVG frames regardless of the value of the 'position'
+   * property.
+   *
+   * The coordinates of the returned rectangle are relative to this frame's
+   * origin.
+   */
+  Maybe<nsRect> GetClipPropClipRect(const nsStyleDisplay* aDisp,
+                                    const nsStyleEffects* aEffects,
+                                    const nsSize& aSize) const;
+
+  /**
+   * Check if this frame is focusable and in the current tab order.
+   * Tabbable is indicated by a nonnegative tabindex & is a subset of focusable.
+   * For example, only the selected radio button in a group is in the 
+   * tab order, unless the radio group has no selection in which case
+   * all of the visible, non-disabled radio buttons in the group are 
+   * in the tab order. On the other hand, all of the visible, non-disabled 
+   * radio buttons are always focusable via clicking or script.
+   * Also, depending on the pref accessibility.tabfocus some widgets may be 
+   * focusable but removed from the tab order. This is the default on
+   * Mac OS X, where fewer items are focusable.
+   * @param  [in, optional] aTabIndex the computed tab index
+   *         < 0 if not tabbable
+   *         == 0 if in normal tab order
+   *         > 0 can be tabbed to in the order specified by this value
+   * @param  [in, optional] aWithMouse, is this focus query for mouse clicking
+   * @return whether the frame is focusable via mouse, kbd or script.
+   */
+  virtual bool IsFocusable(int32_t *aTabIndex = nullptr, bool aWithMouse = false);
+
+  // BOX LAYOUT METHODS
+  // These methods have been migrated from nsIBox and are in the process of
+  // being refactored. DO NOT USE OUTSIDE OF XUL.
+  bool IsXULBoxFrame() const
+  {
+    return IsFrameOfType(nsIFrame::eXULBox);
+  }
+
+  enum Halignment {
+    hAlign_Left,
+    hAlign_Right,
+    hAlign_Center
+  };
+
+  enum Valignment {
+    vAlign_Top,
+    vAlign_Middle,
+    vAlign_BaseLine,
+    vAlign_Bottom
+  };
+
+  /**
+   * This calculates the minimum size required for a box based on its state
+   * @param[in] aBoxLayoutState The desired state to calculate for
+   * @return The minimum size
+   */
+  virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) = 0;
+
+  /**
+   * This calculates the preferred size of a box based on its state
+   * @param[in] aBoxLayoutState The desired state to calculate for
+   * @return The preferred size
+   */
+  virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) = 0;
+
+  /**
+   * This calculates the maximum size for a box based on its state
+   * @param[in] aBoxLayoutState The desired state to calculate for
+   * @return The maximum size
+   */    
+  virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) = 0;
+
+  /**
+   * This returns the minimum size for the scroll area if this frame is
+   * being scrolled. Usually it's (0,0).
+   */
+  virtual nsSize GetXULMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState) = 0;
+
+  // Implemented in nsBox, used in nsBoxFrame
+  uint32_t GetXULOrdinal();
+
+  virtual nscoord GetXULFlex() = 0;
+  virtual nscoord GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) = 0;
+  virtual bool IsXULCollapsed() = 0;
+  // This does not alter the overflow area. If the caller is changing
+  // the box size, the caller is responsible for updating the overflow
+  // area. It's enough to just call XULLayout or SyncLayout on the
+  // box. You can pass true to aRemoveOverflowArea as a
+  // convenience.
+  virtual void SetXULBounds(nsBoxLayoutState& aBoxLayoutState, const nsRect& aRect,
+                            bool aRemoveOverflowAreas = false) = 0;
+  nsresult XULLayout(nsBoxLayoutState& aBoxLayoutState);
+  // Box methods.  Note that these do NOT just get the CSS border, padding,
+  // etc.  They also talk to nsITheme.
+  virtual nsresult GetXULBorderAndPadding(nsMargin& aBorderAndPadding);
+  virtual nsresult GetXULBorder(nsMargin& aBorder)=0;
+  virtual nsresult GetXULPadding(nsMargin& aBorderAndPadding)=0;
+  virtual nsresult GetXULMargin(nsMargin& aMargin)=0;
+  virtual void SetXULLayoutManager(nsBoxLayout* aLayout) { }
+  virtual nsBoxLayout* GetXULLayoutManager() { return nullptr; }
+  nsresult GetXULClientRect(nsRect& aContentRect);
+
+  virtual uint32_t GetXULLayoutFlags()
+  { return 0; }
+
+  // For nsSprocketLayout
+  virtual Valignment GetXULVAlign() const = 0;
+  virtual Halignment GetXULHAlign() const = 0;
+
+  bool IsXULHorizontal() const { return (mState & NS_STATE_IS_HORIZONTAL) != 0; }
+  bool IsXULNormalDirection() const { return (mState & NS_STATE_IS_DIRECTION_NORMAL) != 0; }
+
+  nsresult XULRedraw(nsBoxLayoutState& aState);
+  virtual nsresult XULRelayoutChildAtOrdinal(nsIFrame* aChild)=0;
+
+#ifdef DEBUG_LAYOUT
+  virtual nsresult SetXULDebug(nsBoxLayoutState& aState, bool aDebug)=0;
+  virtual nsresult GetXULDebug(bool& aDebug)=0;
+
+  virtual nsresult XULDumpBox(FILE* out)=0;
+#endif
+
+  static bool AddXULPrefSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth, bool& aHeightSet);
+  static bool AddXULMinSize(nsBoxLayoutState& aState, nsIFrame* aBox,
+                            nsSize& aSize, bool& aWidth, bool& aHeightSet);
+  static bool AddXULMaxSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth, bool& aHeightSet);
+  static bool AddXULFlex(nsIFrame* aBox, nscoord& aFlex);
+
+  // END OF BOX LAYOUT METHODS
+  // The above methods have been migrated from nsIBox and are in the process of
+  // being refactored. DO NOT USE OUTSIDE OF XUL.
+
+  /**
+   * @return true if this text frame ends with a newline character.  It
+   * should return false if this is not a text frame.
+   */
+  virtual bool HasSignificantTerminalNewline() const;
+
+  struct CaretPosition {
+    CaretPosition();
+    ~CaretPosition();
+
+    nsCOMPtr<nsIContent> mResultContent;
+    int32_t              mContentOffset;
+  };
+
+  /**
+   * gets the first or last possible caret position within the frame
+   *
+   * @param  [in] aStart
+   *         true  for getting the first possible caret position
+   *         false for getting the last possible caret position
+   * @return The caret position in a CaretPosition.
+   *         the returned value is a 'best effort' in case errors
+   *         are encountered rummaging through the frame.
+   */
+  CaretPosition GetExtremeCaretPosition(bool aStart);
+
+  /**
+   * Get a line iterator for this frame, if supported.
+   *
+   * @return nullptr if no line iterator is supported.
+   * @note dispose the line iterator using nsILineIterator::DisposeLineIterator
+   */
+  virtual nsILineIterator* GetLineIterator() = 0;
+
+  /**
+   * If this frame is a next-in-flow, and its prev-in-flow has something on its
+   * overflow list, pull those frames into the child list of this one.
+   */
+  virtual void PullOverflowsFromPrevInFlow() {}
+
+  /**
+   * Clear the list of child PresShells generated during the last paint
+   * so that we can begin generating a new one.
+   */  
+  void ClearPresShellsFromLastPaint() { 
+    PaintedPresShellList()->Clear(); 
+  }
+  
+  /**
+   * Flag a child PresShell as painted so that it will get its paint count
+   * incremented during empty transactions.
+   */  
+  void AddPaintedPresShell(nsIPresShell* shell) { 
+    PaintedPresShellList()->AppendElement(do_GetWeakReference(shell));
+  }
+  
+  /**
+   * Increment the paint count of all child PresShells that were painted during
+   * the last repaint.
+   */  
+  void UpdatePaintCountForPaintedPresShells() {
+    for (nsWeakPtr& item : *PaintedPresShellList()) {
+      nsCOMPtr<nsIPresShell> shell = do_QueryReferent(item);
+      if (shell) {
+        shell->IncrementPaintCount();
+      }
+    }
+  }  
+
+  /**
+   * @return true if we painted @aShell during the last repaint.
+   */
+  bool DidPaintPresShell(nsIPresShell* aShell)
+  {
+    for (nsWeakPtr& item : *PaintedPresShellList()) {
+      nsCOMPtr<nsIPresShell> shell = do_QueryReferent(item);
+      if (shell == aShell) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Accessors for the absolute containing block.
+   */
+  bool IsAbsoluteContainer() const { return !!(mState & NS_FRAME_HAS_ABSPOS_CHILDREN); }
+  bool HasAbsolutelyPositionedChildren() const;
+  nsAbsoluteContainingBlock* GetAbsoluteContainingBlock() const;
+  void MarkAsAbsoluteContainingBlock();
+  void MarkAsNotAbsoluteContainingBlock();
+  // Child frame types override this function to select their own child list name
+  virtual mozilla::layout::FrameChildListID GetAbsoluteListID() const { return kAbsoluteList; }
+
+  // Checks if we (or any of our descendents) have NS_FRAME_PAINTED_THEBES set, and
+  // clears this bit if so.
+  bool CheckAndClearPaintedState();
+
+  // CSS visibility just doesn't cut it because it doesn't inherit through
+  // documents. Also if this frame is in a hidden card of a deck then it isn't
+  // visible either and that isn't expressed using CSS visibility. Also if it
+  // is in a hidden view (there are a few cases left and they are hopefully
+  // going away soon).
+  // If the VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY flag is passed then we
+  // ignore the chrome/content boundary, otherwise we stop looking when we
+  // reach it.
+  enum {
+    VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY = 0x01
+  };
+  bool IsVisibleConsideringAncestors(uint32_t aFlags = 0) const;
+
+  struct FrameWithDistance
+  {
+    nsIFrame* mFrame;
+    nscoord mXDistance;
+    nscoord mYDistance;
+  };
+
+  /**
+   * Finds a frame that is closer to a specified point than a current
+   * distance.  Distance is measured as for text selection -- a closer x
+   * distance beats a closer y distance.
+   *
+   * Normally, this function will only check the distance between this
+   * frame's rectangle and the specified point.  SVGTextFrame overrides
+   * this so that it can manage all of its descendant frames and take
+   * into account any SVG text layout.
+   *
+   * If aPoint is closer to this frame's rectangle than aCurrentBestFrame
+   * indicates, then aCurrentBestFrame is updated with the distance between
+   * aPoint and this frame's rectangle, and with a pointer to this frame.
+   * If aPoint is not closer, then aCurrentBestFrame is left unchanged.
+   *
+   * @param aPoint The point to check for its distance to this frame.
+   * @param aCurrentBestFrame Pointer to a struct that will be updated with
+   *   a pointer to this frame and its distance to aPoint, if this frame
+   *   is indeed closer than the current distance in aCurrentBestFrame.
+   */
+  virtual void FindCloserFrameForSelection(nsPoint aPoint,
+                                           FrameWithDistance* aCurrentBestFrame);
+
+  /**
+   * Is this a flex item? (i.e. a non-abs-pos child of a flex container)
+   */
+  inline bool IsFlexItem() const;
+  /**
+   * Is this a flex or grid item? (i.e. a non-abs-pos child of a flex/grid container)
+   */
+  inline bool IsFlexOrGridItem() const;
+  inline bool IsFlexOrGridContainer() const;
+
+  /**
+   * @return true if this frame is used as a table caption.
+   */
+  inline bool IsTableCaption() const;
+
+  inline bool IsBlockInside() const;
+  inline bool IsBlockOutside() const;
+  inline bool IsInlineOutside() const;
+  inline mozilla::StyleDisplay GetDisplay() const;
+  inline bool IsFloating() const;
+  inline bool IsAbsPosContainingBlock() const;
+  inline bool IsFixedPosContainingBlock() const;
+  inline bool IsRelativelyPositioned() const;
+  inline bool IsAbsolutelyPositioned() const;
+
+  /**
+   * Returns the vertical-align value to be used for layout, if it is one
+   * of the enumerated values.  If this is an SVG text frame, it returns a value
+   * that corresponds to the value of dominant-baseline.  If the
+   * vertical-align property has length or percentage value, this returns
+   * eInvalidVerticalAlign.
+   */
+  uint8_t VerticalAlignEnum() const;
+  enum { eInvalidVerticalAlign = 0xFF };
+
+  bool IsSVGText() const { return mState & NS_FRAME_IS_SVG_TEXT; }
+
+  void CreateOwnLayerIfNeeded(nsDisplayListBuilder* aBuilder, nsDisplayList* aList);
+
+  /**
+   * Adds the NS_FRAME_IN_POPUP state bit to aFrame, and
+   * all descendant frames (including cross-doc ones).
+   */
+  static void AddInPopupStateBitToDescendants(nsIFrame* aFrame);
+  /**
+   * Removes the NS_FRAME_IN_POPUP state bit from aFrame and
+   * all descendant frames (including cross-doc ones), unless
+   * the frame is a popup itself.
+   */
+  static void RemoveInPopupStateBitFromDescendants(nsIFrame* aFrame);
+
+  /**
+   * Sorts the given nsFrameList, so that for every two adjacent frames in the
+   * list, the former is less than or equal to the latter, according to the
+   * templated IsLessThanOrEqual method.
+   *
+   * Note: this method uses a stable merge-sort algorithm.
+   */
+  template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+  static void SortFrameList(nsFrameList& aFrameList);
+
+  /**
+   * Returns true if the given frame list is already sorted, according to the
+   * templated IsLessThanOrEqual function.
+   */
+  template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+  static bool IsFrameListSorted(nsFrameList& aFrameList);
+
+  /**
+   * Return true if aFrame is in an {ib} split and is NOT one of the
+   * continuations of the first inline in it.
+   */
+  bool FrameIsNonFirstInIBSplit() const {
+    return (GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) &&
+      FirstContinuation()->Properties().Get(nsIFrame::IBSplitPrevSibling());
+  }
+
+  /**
+   * Return true if aFrame is in an {ib} split and is NOT one of the
+   * continuations of the last inline in it.
+   */
+  bool FrameIsNonLastInIBSplit() const {
+    return (GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) &&
+      FirstContinuation()->Properties().Get(nsIFrame::IBSplitSibling());
+  }
+
+  /**
+   * Return whether this is a frame whose width is used when computing
+   * the font size inflation of its descendants.
+   */
+  bool IsContainerForFontSizeInflation() const {
+    return GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER;
+  }
+
+  /**
+   * Return whether this frame keeps track of overflow areas. (Frames for
+   * non-display SVG elements -- e.g. <clipPath> -- do not maintain overflow
+   * areas, because they're never painted.)
+   */
+  bool FrameMaintainsOverflow() const {
+    return !HasAllStateBits(NS_FRAME_SVG_LAYOUT | NS_FRAME_IS_NONDISPLAY);
+  }
+
+  /**
+   * Returns the content node within the anonymous content that this frame
+   * generated and which corresponds to the specified pseudo-element type,
+   * or nullptr if there is no such anonymous content.
+   */
+  virtual mozilla::dom::Element*
+  GetPseudoElement(mozilla::CSSPseudoElementType aType);
+
+  bool BackfaceIsHidden() const {
+    return StyleDisplay()->BackfaceIsHidden();
+  }
+
+  /**
+   * Returns true if the frame is scrolled out of view.
+   */
+  bool IsScrolledOutOfView();
+
+  /**
+   * If this returns true, the frame it's called on should get the
+   * NS_FRAME_HAS_DIRTY_CHILDREN bit set on it by the caller; either directly
+   * if it's already in reflow, or via calling FrameNeedsReflow() to schedule a
+   * reflow.
+   */
+  virtual bool RenumberFrameAndDescendants(int32_t* aOrdinal,
+                                           int32_t aDepth,
+                                           int32_t aIncrement,
+                                           bool aForCounting) { return false; }
+
+  /**
+   * Helper function - computes the content-box inline size for aCoord.
+   */
+  nscoord ComputeISizeValue(nsRenderingContext* aRenderingContext,
+                            nscoord             aContainingBlockISize,
+                            nscoord             aContentEdgeToBoxSizing,
+                            nscoord             aBoxSizingToMarginEdge,
+                            const nsStyleCoord& aCoord,
+                            ComputeSizeFlags    aFlags = eDefault);
+protected:
+  // Members
+  nsRect           mRect;
+  nsIContent*      mContent;
+  nsStyleContext*  mStyleContext;
+private:
+  nsContainerFrame* mParent;
+  nsIFrame*        mNextSibling;  // doubly-linked list of frames
+  nsIFrame*        mPrevSibling;  // Do not touch outside SetNextSibling!
+
+  void MarkAbsoluteFramesForDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect);
+
+  static void DestroyPaintedPresShellList(nsTArray<nsWeakPtr>* list) {
+    list->Clear();
+    delete list;
+  }
+
+  // Stores weak references to all the PresShells that were painted during
+  // the last paint event so that we can increment their paint count during
+  // empty transactions
+  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(PaintedPresShellsProperty,
+                                      nsTArray<nsWeakPtr>,
+                                      DestroyPaintedPresShellList)
+  
+  nsTArray<nsWeakPtr>* PaintedPresShellList() {
+    nsTArray<nsWeakPtr>* list = Properties().Get(PaintedPresShellsProperty());
+    
+    if (!list) {
+      list = new nsTArray<nsWeakPtr>();
+      Properties().Set(PaintedPresShellsProperty(), list);
+    }
+    
+    return list;
+  }
+
+protected:
+  void MarkInReflow() {
+#ifdef DEBUG_dbaron_off
+    // bug 81268
+    NS_ASSERTION(!(mState & NS_FRAME_IN_REFLOW), "frame is already in reflow");
+#endif
+    mState |= NS_FRAME_IN_REFLOW;
+  }
+
+  nsFrameState     mState;
+
+  // When there is an overflow area only slightly larger than mRect,
+  // we store a set of four 1-byte deltas from the edges of mRect
+  // rather than allocating a whole separate rectangle property.
+  // Note that these are unsigned values, all measured "outwards"
+  // from the edges of mRect, so /mLeft/ and /mTop/ are reversed from
+  // our normal coordinate system.
+  // If mOverflow.mType == NS_FRAME_OVERFLOW_LARGE, then the
+  // delta values are not meaningful and the overflow area is stored
+  // as a separate rect property.
+  struct VisualDeltas {
+    uint8_t mLeft;
+    uint8_t mTop;
+    uint8_t mRight;
+    uint8_t mBottom;
+    bool operator==(const VisualDeltas& aOther) const
+    {
+      return mLeft == aOther.mLeft && mTop == aOther.mTop &&
+             mRight == aOther.mRight && mBottom == aOther.mBottom;
+    }
+    bool operator!=(const VisualDeltas& aOther) const
+    {
+      return !(*this == aOther);
+    }
+  };
+  union {
+    uint32_t     mType;
+    VisualDeltas mVisualDeltas;
+  } mOverflow;
+
+  // Helpers
+  /**
+   * Can we stop inside this frame when we're skipping non-rendered whitespace?
+   * @param  aForward [in] Are we moving forward (or backward) in content order.
+   * @param  aOffset [in/out] At what offset into the frame to start looking.
+   *         on output - what offset was reached (whether or not we found a place to stop).
+   * @return STOP: An appropriate offset was found within this frame,
+   *         and is given by aOffset.
+   *         CONTINUE: Not found within this frame, need to try the next frame.
+   *         see enum FrameSearchResult for more details.
+   */
+  virtual FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) = 0;
+  
+  /**
+   * Search the frame for the next character
+   * @param  aForward [in] Are we moving forward (or backward) in content order.
+   * @param  aOffset [in/out] At what offset into the frame to start looking.
+   *         on output - what offset was reached (whether or not we found a place to stop).
+   * @param  aRespectClusters [in] Whether to restrict result to valid cursor locations
+   *         (between grapheme clusters) - default TRUE maintains "normal" behavior,
+   *         FALSE is used for selection by "code unit" (instead of "character")
+   * @return STOP: An appropriate offset was found within this frame,
+   *         and is given by aOffset.
+   *         CONTINUE: Not found within this frame, need to try the next frame.
+   *         see enum FrameSearchResult for more details.
+   */
+  virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset,
+                                     bool aRespectClusters = true) = 0;
+  
+  /**
+   * Search the frame for the next word boundary
+   * @param  aForward [in] Are we moving forward (or backward) in content order.
+   * @param  aWordSelectEatSpace [in] true: look for non-whitespace following
+   *         whitespace (in the direction of movement).
+   *         false: look for whitespace following non-whitespace (in the
+   *         direction  of movement).
+   * @param  aIsKeyboardSelect [in] Was the action initiated by a keyboard operation?
+   *         If true, punctuation immediately following a word is considered part
+   *         of that word. Otherwise, a sequence of punctuation is always considered
+   *         as a word on its own.
+   * @param  aOffset [in/out] At what offset into the frame to start looking.
+   *         on output - what offset was reached (whether or not we found a place to stop).
+   * @param  aState [in/out] the state that is carried from frame to frame
+   * @return true: An appropriate offset was found within this frame,
+   *         and is given by aOffset.
+   *         false: Not found within this frame, need to try the next frame.
+   */
+  struct PeekWordState {
+    // true when we're still at the start of the search, i.e., we can't return
+    // this point as a valid offset!
+    bool mAtStart;
+    // true when we've encountered at least one character of the pre-boundary type
+    // (whitespace if aWordSelectEatSpace is true, non-whitespace otherwise)
+    bool mSawBeforeType;
+    // true when the last character encountered was punctuation
+    bool mLastCharWasPunctuation;
+    // true when the last character encountered was whitespace
+    bool mLastCharWasWhitespace;
+    // true when we've seen non-punctuation since the last whitespace
+    bool mSeenNonPunctuationSinceWhitespace;
+    // text that's *before* the current frame when aForward is true, *after*
+    // the current frame when aForward is false. Only includes the text
+    // on the current line.
+    nsAutoString mContext;
+
+    PeekWordState() : mAtStart(true), mSawBeforeType(false),
+        mLastCharWasPunctuation(false), mLastCharWasWhitespace(false),
+        mSeenNonPunctuationSinceWhitespace(false) {}
+    void SetSawBeforeType() { mSawBeforeType = true; }
+    void Update(bool aAfterPunctuation, bool aAfterWhitespace) {
+      mLastCharWasPunctuation = aAfterPunctuation;
+      mLastCharWasWhitespace = aAfterWhitespace;
+      if (aAfterWhitespace) {
+        mSeenNonPunctuationSinceWhitespace = false;
+      } else if (!aAfterPunctuation) {
+        mSeenNonPunctuationSinceWhitespace = true;
+      }
+      mAtStart = false;
+    }
+  };
+  virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
+                                int32_t* aOffset, PeekWordState* aState) = 0;
+
+  /**
+   * Search for the first paragraph boundary before or after the given position
+   * @param  aPos See description in nsFrameSelection.h. The following fields are
+   *              used by this method: 
+   *              Input: mDirection
+   *              Output: mResultContent, mContentOffset
+   */
+  nsresult PeekOffsetParagraph(nsPeekOffsetStruct *aPos);
+
+private:
+  nsOverflowAreas* GetOverflowAreasProperty();
+  nsRect GetVisualOverflowFromDeltas() const {
+    MOZ_ASSERT(mOverflow.mType != NS_FRAME_OVERFLOW_LARGE,
+               "should not be called when overflow is in a property");
+    // Calculate the rect using deltas from the frame's border rect.
+    // Note that the mOverflow.mDeltas fields are unsigned, but we will often
+    // need to return negative values for the left and top, so take care
+    // to cast away the unsigned-ness.
+    return nsRect(-(int32_t)mOverflow.mVisualDeltas.mLeft,
+                  -(int32_t)mOverflow.mVisualDeltas.mTop,
+                  mRect.width + mOverflow.mVisualDeltas.mRight +
+                                mOverflow.mVisualDeltas.mLeft,
+                  mRect.height + mOverflow.mVisualDeltas.mBottom +
+                                 mOverflow.mVisualDeltas.mTop);
+  }
+  /**
+   * Returns true if any overflow changed.
+   */
+  bool SetOverflowAreas(const nsOverflowAreas& aOverflowAreas);
+
+  // Helper-functions for SortFrameList():
+  template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+  static nsIFrame* SortedMerge(nsIFrame *aLeft, nsIFrame *aRight);
+
+  template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+  static nsIFrame* MergeSort(nsIFrame *aSource);
+
+  bool HasOpacityInternal(float aThreshold) const;
+
+#ifdef DEBUG_FRAME_DUMP
+public:
+  static void IndentBy(FILE* out, int32_t aIndent) {
+    while (--aIndent >= 0) fputs("  ", out);
+  }
+  void ListTag(FILE* out) const {
+    ListTag(out, this);
+  }
+  static void ListTag(FILE* out, const nsIFrame* aFrame) {
+    nsAutoCString t;
+    ListTag(t, aFrame);
+    fputs(t.get(), out);
+  }
+  static void ListTag(FILE* out, const nsFrameList& aFrameList) {
+    for (nsIFrame* frame : aFrameList) {
+      ListTag(out, frame);
+    }
+  }
+  void ListTag(nsACString& aTo) const;
+  nsAutoCString ListTag() const {
+    nsAutoCString tag;
+    ListTag(tag);
+    return tag;
+  }
+  static void ListTag(nsACString& aTo, const nsIFrame* aFrame);
+  void ListGeneric(nsACString& aTo, const char* aPrefix = "", uint32_t aFlags = 0) const;
+  enum {
+    TRAVERSE_SUBDOCUMENT_FRAMES = 0x01
+  };
+  virtual void List(FILE* out = stderr, const char* aPrefix = "", uint32_t aFlags = 0) const;
+  /**
+   * lists the frames beginning from the root frame
+   * - calls root frame's List(...)
+   */
+  static void RootFrameList(nsPresContext* aPresContext,
+                            FILE* out = stderr, const char* aPrefix = "");
+  virtual void DumpFrameTree() const;
+  void DumpFrameTreeLimited() const;
+
+  virtual nsresult  GetFrameName(nsAString& aResult) const = 0;
+#endif
+
+#ifdef DEBUG
+public:
+  virtual nsFrameState  GetDebugStateBits() const = 0;
+  virtual nsresult  DumpRegressionData(nsPresContext* aPresContext,
+                                       FILE* out, int32_t aIndent) = 0;
+#endif
+};
+
+//----------------------------------------------------------------------
+
+/**
+ * nsWeakFrame can be used to keep a reference to a nsIFrame in a safe way.
+ * Whenever an nsIFrame object is deleted, the nsWeakFrames pointing
+ * to it will be cleared.
+ *
+ * Create nsWeakFrame object when it is sure that nsIFrame object
+ * is alive and after some operations which may destroy the nsIFrame
+ * (for example any DOM modifications) use IsAlive() or GetFrame() methods to
+ * check whether it is safe to continue to use the nsIFrame object.
+ *
+ * @note The usage of this class should be kept to a minimum.
+ */
+
+class nsWeakFrame {
+public:
+  nsWeakFrame() : mPrev(nullptr), mFrame(nullptr) { }
+
+  nsWeakFrame(const nsWeakFrame& aOther) : mPrev(nullptr), mFrame(nullptr)
+  {
+    Init(aOther.GetFrame());
+  }
+
+  MOZ_IMPLICIT nsWeakFrame(nsIFrame* aFrame) : mPrev(nullptr), mFrame(nullptr)
+  {
+    Init(aFrame);
+  }
+
+  nsWeakFrame& operator=(nsWeakFrame& aOther) {
+    Init(aOther.GetFrame());
+    return *this;
+  }
+
+  nsWeakFrame& operator=(nsIFrame* aFrame) {
+    Init(aFrame);
+    return *this;
+  }
+
+  nsIFrame* operator->()
+  {
+    return mFrame;
+  }
+
+  operator nsIFrame*()
+  {
+    return mFrame;
+  }
+
+  void Clear(nsIPresShell* aShell) {
+    if (aShell) {
+      aShell->RemoveWeakFrame(this);
+    }
+    mFrame = nullptr;
+    mPrev = nullptr;
+  }
+
+  bool IsAlive() { return !!mFrame; }
+
+  nsIFrame* GetFrame() const { return mFrame; }
+
+  nsWeakFrame* GetPreviousWeakFrame() { return mPrev; }
+
+  void SetPreviousWeakFrame(nsWeakFrame* aPrev) { mPrev = aPrev; }
+
+  ~nsWeakFrame()
+  {
+    Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr);
+  }
+private:
+  void Init(nsIFrame* aFrame);
+
+  nsWeakFrame*  mPrev;
+  nsIFrame*     mFrame;
+};
+
+inline bool
+nsFrameList::ContinueRemoveFrame(nsIFrame* aFrame)
+{
+  MOZ_ASSERT(!aFrame->GetPrevSibling() || !aFrame->GetNextSibling(),
+             "Forgot to call StartRemoveFrame?");
+  if (aFrame == mLastChild) {
+    MOZ_ASSERT(!aFrame->GetNextSibling(), "broken frame list");
+    nsIFrame* prevSibling = aFrame->GetPrevSibling();
+    if (!prevSibling) {
+      MOZ_ASSERT(aFrame == mFirstChild, "broken frame list");
+      mFirstChild = mLastChild = nullptr;
+      return true;
+    }
+    MOZ_ASSERT(prevSibling->GetNextSibling() == aFrame, "Broken frame linkage");
+    prevSibling->SetNextSibling(nullptr);
+    mLastChild = prevSibling;
+    return true;
+  }
+  if (aFrame == mFirstChild) {
+    MOZ_ASSERT(!aFrame->GetPrevSibling(), "broken frame list");
+    mFirstChild = aFrame->GetNextSibling();
+    aFrame->SetNextSibling(nullptr);
+    MOZ_ASSERT(mFirstChild, "broken frame list");
+    return true;
+  }
+  return false;
+}
+
+inline bool
+nsFrameList::StartRemoveFrame(nsIFrame* aFrame)
+{
+  if (aFrame->GetPrevSibling() && aFrame->GetNextSibling()) {
+    UnhookFrameFromSiblings(aFrame);
+    return true;
+  }
+  return ContinueRemoveFrame(aFrame);
+}
+
+inline void
+nsFrameList::Enumerator::Next()
+{
+  NS_ASSERTION(!AtEnd(), "Should have checked AtEnd()!");
+  mFrame = mFrame->GetNextSibling();
+}
+
+inline
+nsFrameList::FrameLinkEnumerator::
+FrameLinkEnumerator(const nsFrameList& aList, nsIFrame* aPrevFrame)
+  : Enumerator(aList)
+{
+  mPrev = aPrevFrame;
+  mFrame = aPrevFrame ? aPrevFrame->GetNextSibling() : aList.FirstChild();
+}
+
+inline void
+nsFrameList::FrameLinkEnumerator::Next()
+{
+  mPrev = mFrame;
+  Enumerator::Next();
+}
+
+// Operators of nsFrameList::Iterator
+// ---------------------------------------------------
+
+inline nsFrameList::Iterator&
+nsFrameList::Iterator::operator++()
+{
+  mCurrent = mCurrent->GetNextSibling();
+  return *this;
+}
+
+inline nsFrameList::Iterator&
+nsFrameList::Iterator::operator--()
+{
+  if (!mCurrent) {
+    mCurrent = mList.LastChild();
+  } else {
+    mCurrent = mCurrent->GetPrevSibling();
+  }
+  return *this;
+}
+
+// Helper-functions for nsIFrame::SortFrameList()
+// ---------------------------------------------------
+
+template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+/* static */ nsIFrame*
+nsIFrame::SortedMerge(nsIFrame *aLeft, nsIFrame *aRight)
+{
+  NS_PRECONDITION(aLeft && aRight, "SortedMerge must have non-empty lists");
+
+  nsIFrame *result;
+  // Unroll first iteration to avoid null-check 'result' inside the loop.
+  if (IsLessThanOrEqual(aLeft, aRight)) {
+    result = aLeft;
+    aLeft = aLeft->GetNextSibling();
+    if (!aLeft) {
+      result->SetNextSibling(aRight);
+      return result;
+    }
+  }
+  else {
+    result = aRight;
+    aRight = aRight->GetNextSibling();
+    if (!aRight) {
+      result->SetNextSibling(aLeft);
+      return result;
+    }
+  }
+
+  nsIFrame *last = result;
+  for (;;) {
+    if (IsLessThanOrEqual(aLeft, aRight)) {
+      last->SetNextSibling(aLeft);
+      last = aLeft;
+      aLeft = aLeft->GetNextSibling();
+      if (!aLeft) {
+        last->SetNextSibling(aRight);
+        return result;
+      }
+    }
+    else {
+      last->SetNextSibling(aRight);
+      last = aRight;
+      aRight = aRight->GetNextSibling();
+      if (!aRight) {
+        last->SetNextSibling(aLeft);
+        return result;
+      }
+    }
+  }
+}
+
+template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+/* static */ nsIFrame*
+nsIFrame::MergeSort(nsIFrame *aSource)
+{
+  NS_PRECONDITION(aSource, "MergeSort null arg");
+
+  nsIFrame *sorted[32] = { nullptr };
+  nsIFrame **fill = &sorted[0];
+  nsIFrame **left;
+  nsIFrame *rest = aSource;
+
+  do {
+    nsIFrame *current = rest;
+    rest = rest->GetNextSibling();
+    current->SetNextSibling(nullptr);
+
+    // Merge it with sorted[0] if present; then merge the result with sorted[1] etc.
+    // sorted[0] is a list of length 1 (or nullptr).
+    // sorted[1] is a list of length 2 (or nullptr).
+    // sorted[2] is a list of length 4 (or nullptr). etc.
+    for (left = &sorted[0]; left != fill && *left; ++left) {
+      current = SortedMerge<IsLessThanOrEqual>(*left, current);
+      *left = nullptr;
+    }
+
+    // Fill the empty slot that we couldn't merge with the last result.
+    *left = current;
+
+    if (left == fill)
+      ++fill;
+  } while (rest);
+
+  // Collect and merge the results.
+  nsIFrame *result = nullptr;
+  for (left = &sorted[0]; left != fill; ++left) {
+    if (*left) {
+      result = result ? SortedMerge<IsLessThanOrEqual>(*left, result) : *left;
+    }
+  }
+  return result;
+}
+
+template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+/* static */ void
+nsIFrame::SortFrameList(nsFrameList& aFrameList)
+{
+  nsIFrame* head = MergeSort<IsLessThanOrEqual>(aFrameList.FirstChild());
+  aFrameList = nsFrameList(head, nsLayoutUtils::GetLastSibling(head));
+  MOZ_ASSERT(IsFrameListSorted<IsLessThanOrEqual>(aFrameList),
+             "After we sort a frame list, it should be in sorted order...");
+}
+
+template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
+/* static */ bool
+nsIFrame::IsFrameListSorted(nsFrameList& aFrameList)
+{
+  if (aFrameList.IsEmpty()) {
+    // empty lists are trivially sorted.
+    return true;
+  }
+
+  // We'll walk through the list with two iterators, one trailing behind the
+  // other. The list is sorted IFF trailingIter <= iter, across the whole list.
+  nsFrameList::Enumerator trailingIter(aFrameList);
+  nsFrameList::Enumerator iter(aFrameList);
+  iter.Next(); // Skip |iter| past first frame. (List is nonempty, so we can.)
+
+  // Now, advance the iterators in parallel, comparing each adjacent pair.
+  while (!iter.AtEnd()) {
+    MOZ_ASSERT(!trailingIter.AtEnd(), "trailing iter shouldn't finish first");
+    if (!IsLessThanOrEqual(trailingIter.get(), iter.get())) {
+      return false;
+    }
+    trailingIter.Next();
+    iter.Next();
+  }
+
+  // We made it to the end without returning early, so the list is sorted.
+  return true;
+}
+
+#endif /* nsIFrame_h___ */