Add m-esr52 at 52.6.0

1 files changed, 11380 insertions, 0 deletions

diff --git a/layout/generic/nsFrame.cpp b/layout/generic/nsFrame.cpp
new file mode 100644
index 000000000..69791d5c5
--- /dev/null
+++ b/layout/generic/nsFrame.cpp
@@ -0,0 +1,11380 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* base class of all rendering objects */
+
+#include "nsFrame.h"
+
+#include <stdarg.h>
+#include <algorithm>
+
+#include "gfx2DGlue.h"
+#include "gfxUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/PathHelpers.h"
+#include "mozilla/Sprintf.h"
+
+#include "nsCOMPtr.h"
+#include "nsFrameList.h"
+#include "nsPlaceholderFrame.h"
+#include "nsIContent.h"
+#include "nsIContentInlines.h"
+#include "nsContentUtils.h"
+#include "nsCSSPseudoElements.h"
+#include "nsIAtom.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsStyleContext.h"
+#include "nsTableWrapperFrame.h"
+#include "nsView.h"
+#include "nsViewManager.h"
+#include "nsIScrollableFrame.h"
+#include "nsPresContext.h"
+#include "nsStyleConsts.h"
+#include "nsIPresShell.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Sprintf.h"
+#include "nsFrameManager.h"
+#include "nsLayoutUtils.h"
+#include "LayoutLogging.h"
+#include "mozilla/RestyleManager.h"
+#include "mozilla/RestyleManagerHandle.h"
+#include "mozilla/RestyleManagerHandleInlines.h"
+
+#include "nsIDOMNode.h"
+#include "nsISelection.h"
+#include "nsISelectionPrivate.h"
+#include "nsFrameSelection.h"
+#include "nsGkAtoms.h"
+#include "nsHtml5Atoms.h"
+#include "nsCSSAnonBoxes.h"
+
+#include "nsFrameTraversal.h"
+#include "nsRange.h"
+#include "nsITextControlFrame.h"
+#include "nsNameSpaceManager.h"
+#include "nsIPercentBSizeObserver.h"
+#include "nsStyleStructInlines.h"
+#include "FrameLayerBuilder.h"
+#include "ImageLayers.h"
+
+#include "nsBidiPresUtils.h"
+#include "RubyUtils.h"
+#include "nsAnimationManager.h"
+
+// For triple-click pref
+#include "imgIContainer.h"
+#include "imgIRequest.h"
+#include "nsError.h"
+#include "nsContainerFrame.h"
+#include "nsBoxLayoutState.h"
+#include "nsBlockFrame.h"
+#include "nsDisplayList.h"
+#include "nsSVGIntegrationUtils.h"
+#include "nsSVGEffects.h"
+#include "nsChangeHint.h"
+#include "nsDeckFrame.h"
+#include "nsSubDocumentFrame.h"
+#include "SVGTextFrame.h"
+
+#include "gfxContext.h"
+#include "nsRenderingContext.h"
+#include "nsAbsoluteContainingBlock.h"
+#include "DisplayItemScrollClip.h"
+#include "StickyScrollContainer.h"
+#include "nsFontInflationData.h"
+#include "nsRegion.h"
+#include "nsIFrameInlines.h"
+
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/EffectCompositor.h"
+#include "mozilla/EffectSet.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/css/ImageLoader.h"
+#include "mozilla/gfx/Tools.h"
+#include "nsPrintfCString.h"
+#include "ActiveLayerTracker.h"
+
+#include "nsITheme.h"
+#include "nsThemeConstants.h"
+
+using namespace mozilla;
+using namespace mozilla::css;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+typedef nsAbsoluteContainingBlock::AbsPosReflowFlags AbsPosReflowFlags;
+
+// Struct containing cached metrics for box-wrapped frames.
+struct nsBoxLayoutMetrics
+{
+  nsSize mPrefSize;
+  nsSize mMinSize;
+  nsSize mMaxSize;
+
+  nsSize mBlockMinSize;
+  nsSize mBlockPrefSize;
+  nscoord mBlockAscent;
+
+  nscoord mFlex;
+  nscoord mAscent;
+
+  nsSize mLastSize;
+};
+
+struct nsContentAndOffset
+{
+  nsIContent* mContent;
+  int32_t mOffset;
+};
+
+// Some Misc #defines
+#define SELECTION_DEBUG        0
+#define FORCE_SELECTION_UPDATE 1
+#define CALC_DEBUG             0
+
+// This is faster than nsBidiPresUtils::IsFrameInParagraphDirection,
+// because it uses the frame pointer passed in without drilling down to
+// the leaf frame.
+static bool
+IsReversedDirectionFrame(nsIFrame* aFrame)
+{
+  FrameBidiData bidiData = aFrame->GetBidiData();
+  return !IS_SAME_DIRECTION(bidiData.embeddingLevel, bidiData.baseLevel);
+}
+
+#include "nsILineIterator.h"
+
+//non Hack prototypes
+#if 0
+static void RefreshContentFrames(nsPresContext* aPresContext, nsIContent * aStartContent, nsIContent * aEndContent);
+#endif
+
+#include "prenv.h"
+
+NS_DECLARE_FRAME_PROPERTY_DELETABLE(BoxMetricsProperty, nsBoxLayoutMetrics)
+
+static void
+InitBoxMetrics(nsIFrame* aFrame, bool aClear)
+{
+  FrameProperties props = aFrame->Properties();
+  if (aClear) {
+    props.Delete(BoxMetricsProperty());
+  }
+
+  nsBoxLayoutMetrics* metrics = new nsBoxLayoutMetrics();
+  props.Set(BoxMetricsProperty(), metrics);
+
+  static_cast<nsFrame*>(aFrame)->nsFrame::MarkIntrinsicISizesDirty();
+  metrics->mBlockAscent = 0;
+  metrics->mLastSize.SizeTo(0, 0);
+}
+
+static bool
+IsXULBoxWrapped(const nsIFrame* aFrame)
+{
+  return aFrame->GetParent() &&
+         aFrame->GetParent()->IsXULBoxFrame() &&
+         !aFrame->IsXULBoxFrame();
+}
+
+// Formerly the nsIFrameDebug interface
+
+#ifdef DEBUG
+static bool gShowFrameBorders = false;
+
+void nsFrame::ShowFrameBorders(bool aEnable)
+{
+  gShowFrameBorders = aEnable;
+}
+
+bool nsFrame::GetShowFrameBorders()
+{
+  return gShowFrameBorders;
+}
+
+static bool gShowEventTargetFrameBorder = false;
+
+void nsFrame::ShowEventTargetFrameBorder(bool aEnable)
+{
+  gShowEventTargetFrameBorder = aEnable;
+}
+
+bool nsFrame::GetShowEventTargetFrameBorder()
+{
+  return gShowEventTargetFrameBorder;
+}
+
+/**
+ * Note: the log module is created during library initialization which
+ * means that you cannot perform logging before then.
+ */
+mozilla::LazyLogModule nsFrame::sFrameLogModule("frame");
+
+static mozilla::LazyLogModule sStyleVerifyTreeLogModuleInfo("styleverifytree");
+
+static uint32_t gStyleVerifyTreeEnable = 0x55;
+
+bool
+nsFrame::GetVerifyStyleTreeEnable()
+{
+  if (gStyleVerifyTreeEnable == 0x55) {
+      gStyleVerifyTreeEnable = 0 != (int)((mozilla::LogModule*)sStyleVerifyTreeLogModuleInfo)->Level();
+  }
+  return gStyleVerifyTreeEnable;
+}
+
+void
+nsFrame::SetVerifyStyleTreeEnable(bool aEnabled)
+{
+  gStyleVerifyTreeEnable = aEnabled;
+}
+
+#endif
+
+NS_DECLARE_FRAME_PROPERTY_DELETABLE(AbsoluteContainingBlockProperty,
+                                    nsAbsoluteContainingBlock)
+
+bool
+nsIFrame::HasAbsolutelyPositionedChildren() const {
+  return IsAbsoluteContainer() && GetAbsoluteContainingBlock()->HasAbsoluteFrames();
+}
+
+nsAbsoluteContainingBlock*
+nsIFrame::GetAbsoluteContainingBlock() const {
+  NS_ASSERTION(IsAbsoluteContainer(), "The frame is not marked as an abspos container correctly");
+  nsAbsoluteContainingBlock* absCB = Properties().Get(AbsoluteContainingBlockProperty());
+  NS_ASSERTION(absCB, "The frame is marked as an abspos container but doesn't have the property");
+  return absCB;
+}
+
+void
+nsIFrame::MarkAsAbsoluteContainingBlock()
+{
+  MOZ_ASSERT(GetStateBits() & NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);
+  NS_ASSERTION(!Properties().Get(AbsoluteContainingBlockProperty()),
+               "Already has an abs-pos containing block property?");
+  NS_ASSERTION(!HasAnyStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN),
+               "Already has NS_FRAME_HAS_ABSPOS_CHILDREN state bit?");
+  AddStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN);
+  Properties().Set(AbsoluteContainingBlockProperty(), new nsAbsoluteContainingBlock(GetAbsoluteListID()));
+}
+
+void
+nsIFrame::MarkAsNotAbsoluteContainingBlock()
+{
+  NS_ASSERTION(!HasAbsolutelyPositionedChildren(), "Think of the children!");
+  NS_ASSERTION(Properties().Get(AbsoluteContainingBlockProperty()),
+               "Should have an abs-pos containing block property");
+  NS_ASSERTION(HasAnyStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN),
+               "Should have NS_FRAME_HAS_ABSPOS_CHILDREN state bit");
+  MOZ_ASSERT(HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN));
+  RemoveStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN);
+  Properties().Delete(AbsoluteContainingBlockProperty());
+}
+
+bool
+nsIFrame::CheckAndClearPaintedState()
+{
+  bool result = (GetStateBits() & NS_FRAME_PAINTED_THEBES);
+  RemoveStateBits(NS_FRAME_PAINTED_THEBES);
+  
+  nsIFrame::ChildListIterator lists(this);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      nsIFrame* child = childFrames.get();
+      if (child->CheckAndClearPaintedState()) {
+        result = true;
+      }
+    }
+  }
+  return result;
+}
+
+bool
+nsIFrame::IsVisibleConsideringAncestors(uint32_t aFlags) const
+{
+  if (!StyleVisibility()->IsVisible()) {
+    return false;
+  }
+
+  const nsIFrame* frame = this;
+  while (frame) {
+    nsView* view = frame->GetView();
+    if (view && view->GetVisibility() == nsViewVisibility_kHide)
+      return false;
+    
+    nsIFrame* parent = frame->GetParent();
+    nsDeckFrame* deck = do_QueryFrame(parent);
+    if (deck) {
+      if (deck->GetSelectedBox() != frame)
+        return false;
+    }
+
+    if (parent) {
+      frame = parent;
+    } else {
+      parent = nsLayoutUtils::GetCrossDocParentFrame(frame);
+      if (!parent)
+        break;
+
+      if ((aFlags & nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY) == 0 &&
+          parent->PresContext()->IsChrome() && !frame->PresContext()->IsChrome()) {
+        break;
+      }
+
+      if (!parent->StyleVisibility()->IsVisible())
+        return false;
+
+      frame = parent;
+    }
+  }
+
+  return true;
+}
+
+void
+nsIFrame::FindCloserFrameForSelection(
+                                 nsPoint aPoint,
+                                 nsIFrame::FrameWithDistance* aCurrentBestFrame)
+{
+  if (nsLayoutUtils::PointIsCloserToRect(aPoint, mRect,
+                                         aCurrentBestFrame->mXDistance,
+                                         aCurrentBestFrame->mYDistance)) {
+    aCurrentBestFrame->mFrame = this;
+  }
+}
+
+void
+nsIFrame::ContentStatesChanged(mozilla::EventStates aStates)
+{
+}
+
+void
+NS_MergeReflowStatusInto(nsReflowStatus* aPrimary, nsReflowStatus aSecondary)
+{
+  *aPrimary |= aSecondary &
+    (NS_FRAME_NOT_COMPLETE | NS_FRAME_OVERFLOW_INCOMPLETE |
+     NS_FRAME_TRUNCATED | NS_FRAME_REFLOW_NEXTINFLOW);
+  if (*aPrimary & NS_FRAME_NOT_COMPLETE) {
+    *aPrimary &= ~NS_FRAME_OVERFLOW_INCOMPLETE;
+  }
+}
+
+void
+nsWeakFrame::Init(nsIFrame* aFrame)
+{
+  Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr);
+  mFrame = aFrame;
+  if (mFrame) {
+    nsIPresShell* shell = mFrame->PresContext()->GetPresShell();
+    NS_WARNING_ASSERTION(shell, "Null PresShell in nsWeakFrame!");
+    if (shell) {
+      shell->AddWeakFrame(this);
+    } else {
+      mFrame = nullptr;
+    }
+  }
+}
+
+nsIFrame*
+NS_NewEmptyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsFrame(aContext);
+}
+
+nsFrame::nsFrame(nsStyleContext* aContext)
+{
+  MOZ_COUNT_CTOR(nsFrame);
+
+  mState = NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY;
+  mStyleContext = aContext;
+  mStyleContext->AddRef();
+#ifdef DEBUG
+  mStyleContext->FrameAddRef();
+#endif
+}
+
+nsFrame::~nsFrame()
+{
+  MOZ_COUNT_DTOR(nsFrame);
+
+  MOZ_ASSERT(GetVisibility() != Visibility::APPROXIMATELY_VISIBLE,
+             "Visible nsFrame is being destroyed");
+
+  NS_IF_RELEASE(mContent);
+#ifdef DEBUG
+  mStyleContext->FrameRelease();
+#endif
+  mStyleContext->Release();
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsFrame)
+
+// Dummy operator delete.  Will never be called, but must be defined
+// to satisfy some C++ ABIs.
+void
+nsFrame::operator delete(void *, size_t)
+{
+  NS_RUNTIMEABORT("nsFrame::operator delete should never be called");
+}
+
+NS_QUERYFRAME_HEAD(nsFrame)
+  NS_QUERYFRAME_ENTRY(nsIFrame)
+NS_QUERYFRAME_TAIL_INHERITANCE_ROOT
+
+/////////////////////////////////////////////////////////////////////////////
+// nsIFrame
+
+static bool
+IsFontSizeInflationContainer(nsIFrame* aFrame,
+                             const nsStyleDisplay* aStyleDisplay)
+{
+  /*
+   * Font size inflation is built around the idea that we're inflating
+   * the fonts for a pan-and-zoom UI so that when the user scales up a
+   * block or other container to fill the width of the device, the fonts
+   * will be readable.  To do this, we need to pick what counts as a
+   * container.
+   *
+   * From a code perspective, the only hard requirement is that frames
+   * that are line participants
+   * (nsIFrame::IsFrameOfType(nsIFrame::eLineParticipant)) are never
+   * containers, since line layout assumes that the inflation is
+   * consistent within a line.
+   *
+   * This is not an imposition, since we obviously want a bunch of text
+   * (possibly with inline elements) flowing within a block to count the
+   * block (or higher) as its container.
+   *
+   * We also want form controls, including the text in the anonymous
+   * content inside of them, to match each other and the text next to
+   * them, so they and their anonymous content should also not be a
+   * container.
+   *
+   * However, because we can't reliably compute sizes across XUL during
+   * reflow, any XUL frame with a XUL parent is always a container.
+   *
+   * There are contexts where it would be nice if some blocks didn't
+   * count as a container, so that, for example, an indented quotation
+   * didn't end up with a smaller font size.  However, it's hard to
+   * distinguish these situations where we really do want the indented
+   * thing to count as a container, so we don't try, and blocks are
+   * always containers.
+   */
+
+  // The root frame should always be an inflation container.
+  if (!aFrame->GetParent()) {
+    return true;
+  }
+
+  nsIContent *content = aFrame->GetContent();
+  nsIAtom* frameType = aFrame->GetType();
+  bool isInline = (aFrame->GetDisplay() == StyleDisplay::Inline ||
+                   RubyUtils::IsRubyBox(frameType) ||
+                   (aFrame->IsFloating() &&
+                    frameType == nsGkAtoms::letterFrame) ||
+                   // Given multiple frames for the same node, only the
+                   // outer one should be considered a container.
+                   // (Important, e.g., for nsSelectsAreaFrame.)
+                   (aFrame->GetParent()->GetContent() == content) ||
+                   (content && (content->IsAnyOfHTMLElements(nsGkAtoms::option,
+                                                             nsGkAtoms::optgroup,
+                                                             nsGkAtoms::select) ||
+                                content->IsInNativeAnonymousSubtree()))) &&
+                  !(aFrame->IsXULBoxFrame() && aFrame->GetParent()->IsXULBoxFrame());
+  NS_ASSERTION(!aFrame->IsFrameOfType(nsIFrame::eLineParticipant) ||
+               isInline ||
+               // br frames and mathml frames report being line
+               // participants even when their position or display is
+               // set
+               aFrame->GetType() == nsGkAtoms::brFrame ||
+               aFrame->IsFrameOfType(nsIFrame::eMathML),
+               "line participants must not be containers");
+  NS_ASSERTION(aFrame->GetType() != nsGkAtoms::bulletFrame || isInline,
+               "bullets should not be containers");
+  return !isInline;
+}
+
+void
+nsFrame::Init(nsIContent*       aContent,
+              nsContainerFrame* aParent,
+              nsIFrame*         aPrevInFlow)
+{
+  NS_PRECONDITION(!mContent, "Double-initing a frame?");
+  NS_ASSERTION(IsFrameOfType(eDEBUGAllFrames) &&
+               !IsFrameOfType(eDEBUGNoFrames),
+               "IsFrameOfType implementation that doesn't call base class");
+
+  mContent = aContent;
+  mParent = aParent;
+
+  if (aContent) {
+    NS_ADDREF(aContent);
+  }
+
+  if (aPrevInFlow) {
+    // Make sure the general flags bits are the same
+    nsFrameState state = aPrevInFlow->GetStateBits();
+
+    // Make bits that are currently off (see constructor) the same:
+    mState |= state & (NS_FRAME_INDEPENDENT_SELECTION |
+                       NS_FRAME_PART_OF_IBSPLIT |
+                       NS_FRAME_MAY_BE_TRANSFORMED |
+                       NS_FRAME_MAY_HAVE_GENERATED_CONTENT |
+                       NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);
+  } else {
+    PresContext()->ConstructedFrame();
+  }
+  if (GetParent()) {
+    nsFrameState state = GetParent()->GetStateBits();
+
+    // Make bits that are currently off (see constructor) the same:
+    mState |= state & (NS_FRAME_INDEPENDENT_SELECTION |
+                       NS_FRAME_GENERATED_CONTENT |
+                       NS_FRAME_IS_SVG_TEXT |
+                       NS_FRAME_IN_POPUP |
+                       NS_FRAME_IS_NONDISPLAY);
+
+    if (HasAnyStateBits(NS_FRAME_IN_POPUP) && TrackingVisibility()) {
+      // Assume all frames in popups are visible.
+      IncApproximateVisibleCount();
+    }
+  }
+  const nsStyleDisplay *disp = StyleDisplay();
+  if (disp->HasTransform(this) ||
+      (IsFrameOfType(eSupportsCSSTransforms) &&
+       nsLayoutUtils::HasAnimationOfProperty(this, eCSSProperty_transform))) {
+    // The frame gets reconstructed if we toggle the -moz-transform
+    // property, so we can set this bit here and then ignore it.
+    mState |= NS_FRAME_MAY_BE_TRANSFORMED;
+  }
+  if (disp->mPosition == NS_STYLE_POSITION_STICKY &&
+      !aPrevInFlow &&
+      !(mState & NS_FRAME_IS_NONDISPLAY) &&
+      !disp->IsInnerTableStyle()) {
+    // Note that we only add first continuations, but we really only
+    // want to add first continuation-or-ib-split-siblings.  But since we
+    // don't yet know if we're a later part of a block-in-inline split,
+    // we'll just add later members of a block-in-inline split here, and
+    // then StickyScrollContainer will remove them later.
+    // We don't currently support relative positioning of inner table
+    // elements (bug 35168), so exclude them from sticky positioning too.
+    StickyScrollContainer* ssc =
+      StickyScrollContainer::GetStickyScrollContainerForFrame(this);
+    if (ssc) {
+      ssc->AddFrame(this);
+    }
+  }
+
+  if (nsLayoutUtils::FontSizeInflationEnabled(PresContext()) || !GetParent()
+#ifdef DEBUG
+      // We have assertions that check inflation invariants even when
+      // font size inflation is not enabled.
+      || true
+#endif
+      ) {
+    if (IsFontSizeInflationContainer(this, disp)) {
+      AddStateBits(NS_FRAME_FONT_INFLATION_CONTAINER);
+      if (!GetParent() ||
+          // I'd use NS_FRAME_OUT_OF_FLOW, but it's not set yet.
+          disp->IsFloating(this) || disp->IsAbsolutelyPositioned(this)) {
+        AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
+      }
+    }
+    NS_ASSERTION(GetParent() ||
+                 (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER),
+                 "root frame should always be a container");
+  }
+
+  if (PresContext()->PresShell()->AssumeAllFramesVisible() &&
+      TrackingVisibility()) {
+    IncApproximateVisibleCount();
+  }
+
+  DidSetStyleContext(nullptr);
+
+  if (::IsXULBoxWrapped(this))
+    ::InitBoxMetrics(this, false);
+}
+
+void
+nsFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
+    "destroy called on frame while scripts not blocked");
+  NS_ASSERTION(!GetNextSibling() && !GetPrevSibling(),
+               "Frames should be removed before destruction.");
+  NS_ASSERTION(aDestructRoot, "Must specify destruct root");
+  MOZ_ASSERT(!HasAbsolutelyPositionedChildren());
+
+  nsSVGEffects::InvalidateDirectRenderingObservers(this);
+
+  if (StyleDisplay()->mPosition == NS_STYLE_POSITION_STICKY) {
+    StickyScrollContainer* ssc =
+      StickyScrollContainer::GetStickyScrollContainerForFrame(this);
+    if (ssc) {
+      ssc->RemoveFrame(this);
+    }
+  }
+
+  // Get the view pointer now before the frame properties disappear
+  // when we call NotifyDestroyingFrame()
+  nsView* view = GetView();
+  nsPresContext* presContext = PresContext();
+
+  nsIPresShell *shell = presContext->GetPresShell();
+  if (mState & NS_FRAME_OUT_OF_FLOW) {
+    nsPlaceholderFrame* placeholder =
+      shell->FrameManager()->GetPlaceholderFrameFor(this);
+    NS_ASSERTION(!placeholder || (aDestructRoot != this),
+                 "Don't call Destroy() on OOFs, call Destroy() on the placeholder.");
+    NS_ASSERTION(!placeholder ||
+                 nsLayoutUtils::IsProperAncestorFrame(aDestructRoot, placeholder),
+                 "Placeholder relationship should have been torn down already; "
+                 "this might mean we have a stray placeholder in the tree.");
+    if (placeholder) {
+      shell->FrameManager()->UnregisterPlaceholderFrame(placeholder);
+      placeholder->SetOutOfFlowFrame(nullptr);
+    }
+  }
+
+  // If we have any IB split siblings, clear their references to us.
+  // (Note: This has to happen before we call shell->NotifyDestroyingFrame,
+  // because that clears our Properties() table.)
+  if (mState & NS_FRAME_PART_OF_IBSPLIT) {
+    // Delete previous sibling's reference to me.
+    nsIFrame* prevSib = Properties().Get(nsIFrame::IBSplitPrevSibling());
+    if (prevSib) {
+      NS_WARNING_ASSERTION(
+        this == prevSib->Properties().Get(nsIFrame::IBSplitSibling()),
+        "IB sibling chain is inconsistent");
+      prevSib->Properties().Delete(nsIFrame::IBSplitSibling());
+    }
+
+    // Delete next sibling's reference to me.
+    nsIFrame* nextSib = Properties().Get(nsIFrame::IBSplitSibling());
+    if (nextSib) {
+      NS_WARNING_ASSERTION(
+        this == nextSib->Properties().Get(nsIFrame::IBSplitPrevSibling()),
+        "IB sibling chain is inconsistent");
+      nextSib->Properties().Delete(nsIFrame::IBSplitPrevSibling());
+    }
+  }
+
+  bool isPrimaryFrame = (mContent && mContent->GetPrimaryFrame() == this);
+  if (isPrimaryFrame) {
+    // This needs to happen before shell->NotifyDestroyingFrame because
+    // that clears our Properties() table.
+    ActiveLayerTracker::TransferActivityToContent(this, mContent);
+
+    // Unfortunately, we need to do this for all frames being reframed
+    // and not only those whose current style involves CSS transitions,
+    // because what matters is whether the new style (not the old)
+    // specifies CSS transitions.
+    if (presContext->RestyleManager()->IsGecko()) {
+      // stylo: ServoRestyleManager does not handle transitions yet, and when
+      // it does it probably won't need to track reframed style contexts to
+      // initiate transitions correctly.
+      RestyleManager::ReframingStyleContexts* rsc =
+        presContext->RestyleManager()->AsGecko()->GetReframingStyleContexts();
+      if (rsc) {
+        rsc->Put(mContent, mStyleContext);
+      }
+    }
+  }
+
+  if (HasCSSAnimations() || HasCSSTransitions() ||
+      EffectSet::GetEffectSet(this)) {
+    // If no new frame for this element is created by the end of the
+    // restyling process, stop animations and transitions for this frame
+    if (presContext->RestyleManager()->IsGecko()) {
+      RestyleManager::AnimationsWithDestroyedFrame* adf =
+        presContext->RestyleManager()->AsGecko()->GetAnimationsWithDestroyedFrame();
+      // AnimationsWithDestroyedFrame only lives during the restyling process.
+      if (adf) {
+        adf->Put(mContent, mStyleContext);
+      }
+    } else {
+      NS_ERROR("stylo: ServoRestyleManager does not support animations yet");
+    }
+  }
+
+  // Disable visibility tracking. Note that we have to do this before calling
+  // NotifyDestroyingFrame(), which will clear frame properties and make us lose
+  // track of whether we were previously visible or not.
+  // XXX(seth): It'd be ideal to assert that we're already marked nonvisible
+  // here, but it's unfortunately tricky to guarantee in the face of things like
+  // frame reconstruction induced by style changes.
+  DisableVisibilityTracking();
+
+  // Ensure that we're not in the approximately visible list anymore.
+  PresContext()->GetPresShell()->RemoveFrameFromApproximatelyVisibleList(this);
+
+  shell->NotifyDestroyingFrame(this);
+
+  if (mState & NS_FRAME_EXTERNAL_REFERENCE) {
+    shell->ClearFrameRefs(this);
+  }
+
+  if (view) {
+    // Break association between view and frame
+    view->SetFrame(nullptr);
+
+    // Destroy the view
+    view->Destroy();
+  }
+
+  // Make sure that our deleted frame can't be returned from GetPrimaryFrame()
+  if (isPrimaryFrame) {
+    mContent->SetPrimaryFrame(nullptr);
+  }
+
+  // Must retrieve the object ID before calling destructors, so the
+  // vtable is still valid.
+  //
+  // Note to future tweakers: having the method that returns the
+  // object size call the destructor will not avoid an indirect call;
+  // the compiler cannot devirtualize the call to the destructor even
+  // if it's from a method defined in the same class.
+
+  nsQueryFrame::FrameIID id = GetFrameId();
+  this->~nsFrame();
+
+  // Now that we're totally cleaned out, we need to add ourselves to
+  // the presshell's recycler.
+  shell->FreeFrame(id, this);
+}
+
+nsresult
+nsFrame::GetOffsets(int32_t &aStart, int32_t &aEnd) const
+{
+  aStart = 0;
+  aEnd = 0;
+  return NS_OK;
+}
+
+static
+void
+AddAndRemoveImageAssociations(nsFrame* aFrame,
+                              const nsStyleImageLayers* aOldLayers,
+                              const nsStyleImageLayers* aNewLayers)
+{
+   ImageLoader* imageLoader =
+     aFrame->PresContext()->Document()->StyleImageLoader();
+
+  // If the old context had a background-image image, or mask-image image,
+  // and new context does not have the same image, clear the image load
+  // notifier (which keeps the image loading, if it still is) for the frame.
+  // We want to do this conservatively because some frames paint their
+  // backgrounds from some other frame's style data, and we don't want
+  // to clear those notifiers unless we have to.  (They'll be reset
+  // when we paint, although we could miss a notification in that
+  // interval.)
+
+  if (aOldLayers) {
+    NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, (*aOldLayers)) {
+      // If there is an image in oldBG that's not in newBG, drop it.
+      if (i >= aNewLayers->mImageCount ||
+          !aOldLayers->mLayers[i].mImage.ImageDataEquals(
+            aNewLayers->mLayers[i].mImage)) {
+        const nsStyleImage& oldImage = aOldLayers->mLayers[i].mImage;
+        if (oldImage.GetType() != eStyleImageType_Image) {
+          continue;
+        }
+
+        if (imgRequestProxy* req = oldImage.GetImageData()) {
+          imageLoader->DisassociateRequestFromFrame(req, aFrame);
+        }
+      }
+    }
+  }
+
+  NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, (*aNewLayers)) {
+    // If there is an image in newBG that's not in oldBG, add it.
+    if (!aOldLayers || i >= aOldLayers->mImageCount ||
+        !aNewLayers->mLayers[i].mImage.ImageDataEquals(
+          aOldLayers->mLayers[i].mImage)) {
+      const nsStyleImage& newImage = aNewLayers->mLayers[i].mImage;
+      if (newImage.GetType() != eStyleImageType_Image) {
+        continue;
+      }
+
+      if (imgRequestProxy* req = newImage.GetImageData()) {
+        imageLoader->AssociateRequestToFrame(req, aFrame);
+      }
+    }
+  }
+}
+
+// Subclass hook for style post processing
+/* virtual */ void
+nsFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
+{
+  if (IsSVGText()) {
+    SVGTextFrame* svgTextFrame = static_cast<SVGTextFrame*>(
+        nsLayoutUtils::GetClosestFrameOfType(this, nsGkAtoms::svgTextFrame));
+    nsIFrame* anonBlock = svgTextFrame->PrincipalChildList().FirstChild();
+    // Just as in SVGTextFrame::DidSetStyleContext, we need to ensure that
+    // any non-display SVGTextFrames get reflowed when a child text frame
+    // gets new style.
+    //
+    // Note that we must check NS_FRAME_FIRST_REFLOW on our SVGTextFrame's
+    // anonymous block frame rather than our self, since NS_FRAME_FIRST_REFLOW
+    // may be set on us if we're a new frame that has been inserted after the
+    // document's first reflow. (In which case this DidSetStyleContext call may
+    // be happening under frame construction under a Reflow() call.)
+    if (anonBlock && !(anonBlock->GetStateBits() & NS_FRAME_FIRST_REFLOW) &&
+        (svgTextFrame->GetStateBits() & NS_FRAME_IS_NONDISPLAY) &&
+        !(svgTextFrame->GetStateBits() & NS_STATE_SVG_TEXT_IN_REFLOW)) {
+      svgTextFrame->ScheduleReflowSVGNonDisplayText(nsIPresShell::eStyleChange);
+    }
+  }
+
+  const nsStyleImageLayers *oldLayers = aOldStyleContext ?
+                              &aOldStyleContext->StyleBackground()->mImage :
+                              nullptr;
+  const nsStyleImageLayers *newLayers = &StyleBackground()->mImage;
+  AddAndRemoveImageAssociations(this, oldLayers, newLayers);
+
+  oldLayers = aOldStyleContext ? &aOldStyleContext->StyleSVGReset()->mMask :
+                                  nullptr;
+  newLayers = &StyleSVGReset()->mMask;
+  AddAndRemoveImageAssociations(this, oldLayers, newLayers);
+
+  if (aOldStyleContext) {
+    // If we detect a change on margin, padding or border, we store the old
+    // values on the frame itself between now and reflow, so if someone
+    // calls GetUsed(Margin|Border|Padding)() before the next reflow, we
+    // can give an accurate answer.
+    // We don't want to set the property if one already exists.
+    FrameProperties props = Properties();
+    nsMargin oldValue(0, 0, 0, 0);
+    nsMargin newValue(0, 0, 0, 0);
+    const nsStyleMargin* oldMargin = aOldStyleContext->PeekStyleMargin();
+    if (oldMargin && oldMargin->GetMargin(oldValue)) {
+      if ((!StyleMargin()->GetMargin(newValue) || oldValue != newValue) &&
+          !props.Get(UsedMarginProperty())) {
+        props.Set(UsedMarginProperty(), new nsMargin(oldValue));
+      }
+    }
+
+    const nsStylePadding* oldPadding = aOldStyleContext->PeekStylePadding();
+    if (oldPadding && oldPadding->GetPadding(oldValue)) {
+      if ((!StylePadding()->GetPadding(newValue) || oldValue != newValue) &&
+          !props.Get(UsedPaddingProperty())) {
+        props.Set(UsedPaddingProperty(), new nsMargin(oldValue));
+      }
+    }
+
+    const nsStyleBorder* oldBorder = aOldStyleContext->PeekStyleBorder();
+    if (oldBorder) {
+      oldValue = oldBorder->GetComputedBorder();
+      newValue = StyleBorder()->GetComputedBorder();
+      if (oldValue != newValue &&
+          !props.Get(UsedBorderProperty())) {
+        props.Set(UsedBorderProperty(), new nsMargin(oldValue));
+      }
+    }
+  }
+
+  ImageLoader* imageLoader = PresContext()->Document()->StyleImageLoader();
+  imgIRequest *oldBorderImage = aOldStyleContext
+    ? aOldStyleContext->StyleBorder()->GetBorderImageRequest()
+    : nullptr;
+  imgIRequest *newBorderImage = StyleBorder()->GetBorderImageRequest();
+  // FIXME (Bug 759996): The following is no longer true.
+  // For border-images, we can't be as conservative (we need to set the
+  // new loaders if there has been any change) since the CalcDifference
+  // call depended on the result of GetComputedBorder() and that result
+  // depends on whether the image has loaded, start the image load now
+  // so that we'll get notified when it completes loading and can do a
+  // restyle.  Otherwise, the image might finish loading from the
+  // network before we start listening to its notifications, and then
+  // we'll never know that it's finished loading.  Likewise, we want to
+  // do this for freshly-created frames to prevent a similar race if the
+  // image loads between reflow (which can depend on whether the image
+  // is loaded) and paint.  We also don't really care about any callers
+  // who try to paint borders with a different style context, because
+  // they won't have the correct size for the border either.
+  if (oldBorderImage != newBorderImage) {
+    // stop and restart the image loading/notification
+    if (oldBorderImage) {
+      imageLoader->DisassociateRequestFromFrame(oldBorderImage, this);
+    }
+    if (newBorderImage) {
+      imageLoader->AssociateRequestToFrame(newBorderImage, this);
+    }
+  }
+
+  // If the page contains markup that overrides text direction, and
+  // does not contain any characters that would activate the Unicode
+  // bidi algorithm, we need to call |SetBidiEnabled| on the pres
+  // context before reflow starts.  See bug 115921.
+  if (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) {
+    PresContext()->SetBidiEnabled();
+  }
+
+  RemoveStateBits(NS_FRAME_SIMPLE_EVENT_REGIONS);
+}
+
+// MSVC fails with link error "one or more multiply defined symbols found",
+// gcc fails with "hidden symbol `nsIFrame::kPrincipalList' isn't defined"
+// etc if they are not defined.
+#ifndef _MSC_VER
+// static nsIFrame constants; initialized in the header file.
+const nsIFrame::ChildListID nsIFrame::kPrincipalList;
+const nsIFrame::ChildListID nsIFrame::kAbsoluteList;
+const nsIFrame::ChildListID nsIFrame::kBulletList;
+const nsIFrame::ChildListID nsIFrame::kCaptionList;
+const nsIFrame::ChildListID nsIFrame::kColGroupList;
+const nsIFrame::ChildListID nsIFrame::kExcessOverflowContainersList;
+const nsIFrame::ChildListID nsIFrame::kFixedList;
+const nsIFrame::ChildListID nsIFrame::kFloatList;
+const nsIFrame::ChildListID nsIFrame::kOverflowContainersList;
+const nsIFrame::ChildListID nsIFrame::kOverflowList;
+const nsIFrame::ChildListID nsIFrame::kOverflowOutOfFlowList;
+const nsIFrame::ChildListID nsIFrame::kPopupList;
+const nsIFrame::ChildListID nsIFrame::kPushedFloatsList;
+const nsIFrame::ChildListID nsIFrame::kSelectPopupList;
+const nsIFrame::ChildListID nsIFrame::kNoReflowPrincipalList;
+#endif
+
+/* virtual */ nsMargin
+nsIFrame::GetUsedMargin() const
+{
+  nsMargin margin(0, 0, 0, 0);
+  if (((mState & NS_FRAME_FIRST_REFLOW) &&
+       !(mState & NS_FRAME_IN_REFLOW)) ||
+      IsSVGText())
+    return margin;
+
+  nsMargin *m = Properties().Get(UsedMarginProperty());
+  if (m) {
+    margin = *m;
+  } else {
+    if (!StyleMargin()->GetMargin(margin)) {
+      // If we get here, our caller probably shouldn't be calling us...
+      NS_ERROR("Returning bogus 0-sized margin, because this margin "
+               "depends on layout & isn't cached!");
+    }
+  }
+  return margin;
+}
+
+/* virtual */ nsMargin
+nsIFrame::GetUsedBorder() const
+{
+  nsMargin border(0, 0, 0, 0);
+  if (((mState & NS_FRAME_FIRST_REFLOW) &&
+       !(mState & NS_FRAME_IN_REFLOW)) ||
+      IsSVGText())
+    return border;
+
+  // Theme methods don't use const-ness.
+  nsIFrame *mutable_this = const_cast<nsIFrame*>(this);
+
+  const nsStyleDisplay *disp = StyleDisplay();
+  if (mutable_this->IsThemed(disp)) {
+    nsIntMargin result;
+    nsPresContext *presContext = PresContext();
+    presContext->GetTheme()->GetWidgetBorder(presContext->DeviceContext(),
+                                             mutable_this, disp->mAppearance,
+                                             &result);
+    border.left = presContext->DevPixelsToAppUnits(result.left);
+    border.top = presContext->DevPixelsToAppUnits(result.top);
+    border.right = presContext->DevPixelsToAppUnits(result.right);
+    border.bottom = presContext->DevPixelsToAppUnits(result.bottom);
+    return border;
+  }
+
+  nsMargin *b = Properties().Get(UsedBorderProperty());
+  if (b) {
+    border = *b;
+  } else {
+    border = StyleBorder()->GetComputedBorder();
+  }
+  return border;
+}
+
+/* virtual */ nsMargin
+nsIFrame::GetUsedPadding() const
+{
+  nsMargin padding(0, 0, 0, 0);
+  if (((mState & NS_FRAME_FIRST_REFLOW) &&
+       !(mState & NS_FRAME_IN_REFLOW)) ||
+      IsSVGText())
+    return padding;
+
+  // Theme methods don't use const-ness.
+  nsIFrame *mutable_this = const_cast<nsIFrame*>(this);
+
+  const nsStyleDisplay *disp = StyleDisplay();
+  if (mutable_this->IsThemed(disp)) {
+    nsPresContext *presContext = PresContext();
+    nsIntMargin widget;
+    if (presContext->GetTheme()->GetWidgetPadding(presContext->DeviceContext(),
+                                                  mutable_this,
+                                                  disp->mAppearance,
+                                                  &widget)) {
+      padding.top = presContext->DevPixelsToAppUnits(widget.top);
+      padding.right = presContext->DevPixelsToAppUnits(widget.right);
+      padding.bottom = presContext->DevPixelsToAppUnits(widget.bottom);
+      padding.left = presContext->DevPixelsToAppUnits(widget.left);
+      return padding;
+    }
+  }
+
+  nsMargin *p = Properties().Get(UsedPaddingProperty());
+  if (p) {
+    padding = *p;
+  } else {
+    if (!StylePadding()->GetPadding(padding)) {
+      // If we get here, our caller probably shouldn't be calling us...
+      NS_ERROR("Returning bogus 0-sized padding, because this padding "
+               "depends on layout & isn't cached!");
+    }
+  }
+  return padding;
+}
+
+nsIFrame::Sides
+nsIFrame::GetSkipSides(const ReflowInput* aReflowInput) const
+{
+  if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
+                     StyleBoxDecorationBreak::Clone) &&
+      !(GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+    return Sides();
+  }
+
+  // Convert the logical skip sides to physical sides using the frame's
+  // writing mode
+  WritingMode writingMode = GetWritingMode();
+  LogicalSides logicalSkip = GetLogicalSkipSides(aReflowInput);
+  Sides skip;
+
+  if (logicalSkip.BStart()) {
+    if (writingMode.IsVertical()) {
+      skip |= writingMode.IsVerticalLR() ? eSideBitsLeft : eSideBitsRight;
+    } else {
+      skip |= eSideBitsTop;
+    }
+  }
+
+  if (logicalSkip.BEnd()) {
+    if (writingMode.IsVertical()) {
+      skip |= writingMode.IsVerticalLR() ? eSideBitsRight : eSideBitsLeft;
+    } else {
+      skip |= eSideBitsBottom;
+    }
+  }
+
+  if (logicalSkip.IStart()) {
+    if (writingMode.IsVertical()) {
+      skip |= eSideBitsTop;
+    } else {
+      skip |= writingMode.IsBidiLTR() ? eSideBitsLeft : eSideBitsRight;
+    }
+  }
+
+  if (logicalSkip.IEnd()) {
+    if (writingMode.IsVertical()) {
+      skip |= eSideBitsBottom;
+    } else {
+      skip |= writingMode.IsBidiLTR() ? eSideBitsRight : eSideBitsLeft;
+    }
+  }
+  return skip;
+}
+
+nsRect
+nsIFrame::GetPaddingRectRelativeToSelf() const
+{
+  nsMargin border(GetUsedBorder());
+  border.ApplySkipSides(GetSkipSides());
+  nsRect r(0, 0, mRect.width, mRect.height);
+  r.Deflate(border);
+  return r;
+}
+
+nsRect
+nsIFrame::GetPaddingRect() const
+{
+  return GetPaddingRectRelativeToSelf() + GetPosition();
+}
+
+WritingMode
+nsIFrame::GetWritingMode(nsIFrame* aSubFrame) const
+{
+  WritingMode writingMode = GetWritingMode();
+
+  if (StyleTextReset()->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_PLAINTEXT) {
+    nsBidiLevel frameLevel = nsBidiPresUtils::GetFrameBaseLevel(aSubFrame);
+    writingMode.SetDirectionFromBidiLevel(frameLevel);
+  }
+
+  return writingMode;
+}
+
+nsRect
+nsIFrame::GetMarginRectRelativeToSelf() const
+{
+  nsMargin m = GetUsedMargin();
+  m.ApplySkipSides(GetSkipSides());
+  nsRect r(0, 0, mRect.width, mRect.height);
+  r.Inflate(m);
+  return r;
+}
+
+bool
+nsIFrame::IsTransformed() const
+{
+  return ((mState & NS_FRAME_MAY_BE_TRANSFORMED) &&
+          (StyleDisplay()->HasTransform(this) ||
+           IsSVGTransformed() ||
+           (mContent &&
+            nsLayoutUtils::HasAnimationOfProperty(this,
+                                                  eCSSProperty_transform) &&
+            IsFrameOfType(eSupportsCSSTransforms) &&
+            mContent->GetPrimaryFrame() == this)));
+}
+
+bool
+nsIFrame::HasOpacityInternal(float aThreshold) const
+{
+  MOZ_ASSERT(0.0 <= aThreshold && aThreshold <= 1.0, "Invalid argument");
+  return StyleEffects()->mOpacity < aThreshold ||
+         (StyleDisplay()->mWillChangeBitField & NS_STYLE_WILL_CHANGE_OPACITY) ||
+         (mContent &&
+           nsLayoutUtils::HasAnimationOfProperty(this, eCSSProperty_opacity) &&
+           mContent->GetPrimaryFrame() == this);
+}
+
+bool
+nsIFrame::IsSVGTransformed(gfx::Matrix *aOwnTransforms,
+                           gfx::Matrix *aFromParentTransforms) const
+{
+  return false;
+}
+
+bool
+nsIFrame::Extend3DContext() const
+{
+  const nsStyleDisplay* disp = StyleDisplay();
+  if (disp->mTransformStyle != NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D ||
+      !IsFrameOfType(nsIFrame::eSupportsCSSTransforms)) {
+    return false;
+  }
+
+  // If we're all scroll frame, then all descendants will be clipped, so we can't preserve 3d.
+  if (GetType() == nsGkAtoms::scrollFrame) {
+    return false;
+  }
+
+  if (HasOpacity()) {
+    return false;
+  }
+
+  const nsStyleEffects* effects = StyleEffects();
+  return !nsFrame::ShouldApplyOverflowClipping(this, disp) &&
+         !GetClipPropClipRect(disp, effects, GetSize()) &&
+         !nsSVGIntegrationUtils::UsingEffectsForFrame(this);
+}
+
+bool
+nsIFrame::Combines3DTransformWithAncestors() const
+{
+  if (!GetParent() || !GetParent()->Extend3DContext()) {
+    return false;
+  }
+  return IsTransformed() || BackfaceIsHidden();
+}
+
+bool
+nsIFrame::In3DContextAndBackfaceIsHidden() const
+{
+  return Combines3DTransformWithAncestors() && BackfaceIsHidden();
+}
+
+bool
+nsIFrame::HasPerspective() const
+{
+  if (!IsTransformed()) {
+    return false;
+  }
+  nsIFrame* containingBlock = GetContainingBlock(SKIP_SCROLLED_FRAME);
+  if (!containingBlock) {
+    return false;
+  }
+  return containingBlock->ChildrenHavePerspective();
+}
+
+bool
+nsIFrame::ChildrenHavePerspective() const
+{
+  return StyleDisplay()->HasPerspectiveStyle();
+}
+
+nsRect
+nsIFrame::GetContentRectRelativeToSelf() const
+{
+  nsMargin bp(GetUsedBorderAndPadding());
+  bp.ApplySkipSides(GetSkipSides());
+  nsRect r(0, 0, mRect.width, mRect.height);
+  r.Deflate(bp);
+  return r;
+}
+
+nsRect
+nsIFrame::GetContentRect() const
+{
+  return GetContentRectRelativeToSelf() + GetPosition();
+}
+
+bool
+nsIFrame::ComputeBorderRadii(const nsStyleCorners& aBorderRadius,
+                             const nsSize& aFrameSize,
+                             const nsSize& aBorderArea,
+                             Sides aSkipSides,
+                             nscoord aRadii[8])
+{
+  // Percentages are relative to whichever side they're on.
+  NS_FOR_CSS_HALF_CORNERS(i) {
+    const nsStyleCoord c = aBorderRadius.Get(i);
+    nscoord axis =
+      NS_HALF_CORNER_IS_X(i) ? aFrameSize.width : aFrameSize.height;
+
+    if (c.IsCoordPercentCalcUnit()) {
+      aRadii[i] = nsRuleNode::ComputeCoordPercentCalc(c, axis);
+      if (aRadii[i] < 0) {
+        // clamp calc()
+        aRadii[i] = 0;
+      }
+    } else {
+      NS_NOTREACHED("ComputeBorderRadii: bad unit");
+      aRadii[i] = 0;
+    }
+  }
+
+  if (aSkipSides.Top()) {
+    aRadii[NS_CORNER_TOP_LEFT_X] = 0;
+    aRadii[NS_CORNER_TOP_LEFT_Y] = 0;
+    aRadii[NS_CORNER_TOP_RIGHT_X] = 0;
+    aRadii[NS_CORNER_TOP_RIGHT_Y] = 0;
+  }
+
+  if (aSkipSides.Right()) {
+    aRadii[NS_CORNER_TOP_RIGHT_X] = 0;
+    aRadii[NS_CORNER_TOP_RIGHT_Y] = 0;
+    aRadii[NS_CORNER_BOTTOM_RIGHT_X] = 0;
+    aRadii[NS_CORNER_BOTTOM_RIGHT_Y] = 0;
+  }
+
+  if (aSkipSides.Bottom()) {
+    aRadii[NS_CORNER_BOTTOM_RIGHT_X] = 0;
+    aRadii[NS_CORNER_BOTTOM_RIGHT_Y] = 0;
+    aRadii[NS_CORNER_BOTTOM_LEFT_X] = 0;
+    aRadii[NS_CORNER_BOTTOM_LEFT_Y] = 0;
+  }
+
+  if (aSkipSides.Left()) {
+    aRadii[NS_CORNER_BOTTOM_LEFT_X] = 0;
+    aRadii[NS_CORNER_BOTTOM_LEFT_Y] = 0;
+    aRadii[NS_CORNER_TOP_LEFT_X] = 0;
+    aRadii[NS_CORNER_TOP_LEFT_Y] = 0;
+  }
+
+  // css3-background specifies this algorithm for reducing
+  // corner radii when they are too big.
+  bool haveRadius = false;
+  double ratio = 1.0f;
+  NS_FOR_CSS_SIDES(side) {
+    uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, true);
+    uint32_t hc2 = NS_SIDE_TO_HALF_CORNER(side, true, true);
+    nscoord length =
+      NS_SIDE_IS_VERTICAL(side) ? aBorderArea.height : aBorderArea.width;
+    nscoord sum = aRadii[hc1] + aRadii[hc2];
+    if (sum)
+      haveRadius = true;
+
+    // avoid floating point division in the normal case
+    if (length < sum)
+      ratio = std::min(ratio, double(length)/sum);
+  }
+  if (ratio < 1.0) {
+    NS_FOR_CSS_HALF_CORNERS(corner) {
+      aRadii[corner] *= ratio;
+    }
+  }
+
+  return haveRadius;
+}
+
+/* static */ void
+nsIFrame::InsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets)
+{
+  NS_FOR_CSS_SIDES(side) {
+    nscoord offset = aOffsets.Side(side);
+    uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, false);
+    uint32_t hc2 = NS_SIDE_TO_HALF_CORNER(side, true, false);
+    aRadii[hc1] = std::max(0, aRadii[hc1] - offset);
+    aRadii[hc2] = std::max(0, aRadii[hc2] - offset);
+  }
+}
+
+/* static */ void
+nsIFrame::OutsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets)
+{
+  NS_FOR_CSS_SIDES(side) {
+    nscoord offset = aOffsets.Side(side);
+    uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, false);
+    uint32_t hc2 = NS_SIDE_TO_HALF_CORNER(side, true, false);
+    if (aRadii[hc1] > 0)
+      aRadii[hc1] += offset;
+    if (aRadii[hc2] > 0)
+      aRadii[hc2] += offset;
+  }
+}
+
+/* virtual */ bool
+nsIFrame::GetBorderRadii(const nsSize& aFrameSize, const nsSize& aBorderArea,
+                         Sides aSkipSides, nscoord aRadii[8]) const
+{
+  if (IsThemed()) {
+    // When we're themed, the native theme code draws the border and
+    // background, and therefore it doesn't make sense to tell other
+    // code that's interested in border-radius that we have any radii.
+    //
+    // In an ideal world, we might have a way for the them to tell us an
+    // border radius, but since we don't, we're better off assuming
+    // zero.
+    NS_FOR_CSS_HALF_CORNERS(corner) {
+      aRadii[corner] = 0;
+    }
+    return false;
+  }
+  return ComputeBorderRadii(StyleBorder()->mBorderRadius,
+                            aFrameSize, aBorderArea,
+                            aSkipSides, aRadii);
+}
+
+bool
+nsIFrame::GetBorderRadii(nscoord aRadii[8]) const
+{
+  nsSize sz = GetSize();
+  return GetBorderRadii(sz, sz, GetSkipSides(), aRadii);
+}
+
+bool
+nsIFrame::GetPaddingBoxBorderRadii(nscoord aRadii[8]) const
+{
+  if (!GetBorderRadii(aRadii))
+    return false;
+  InsetBorderRadii(aRadii, GetUsedBorder());
+  NS_FOR_CSS_HALF_CORNERS(corner) {
+    if (aRadii[corner])
+      return true;
+  }
+  return false;
+}
+
+bool
+nsIFrame::GetContentBoxBorderRadii(nscoord aRadii[8]) const
+{
+  if (!GetBorderRadii(aRadii))
+    return false;
+  InsetBorderRadii(aRadii, GetUsedBorderAndPadding());
+  NS_FOR_CSS_HALF_CORNERS(corner) {
+    if (aRadii[corner])
+      return true;
+  }
+  return false;
+}
+
+nsStyleContext*
+nsFrame::GetAdditionalStyleContext(int32_t aIndex) const
+{
+  NS_PRECONDITION(aIndex >= 0, "invalid index number");
+  return nullptr;
+}
+
+void
+nsFrame::SetAdditionalStyleContext(int32_t aIndex, 
+                                   nsStyleContext* aStyleContext)
+{
+  NS_PRECONDITION(aIndex >= 0, "invalid index number");
+}
+
+nscoord
+nsFrame::GetLogicalBaseline(WritingMode aWritingMode) const
+{
+  NS_ASSERTION(!NS_SUBTREE_DIRTY(this),
+               "frame must not be dirty");
+  // Baseline for inverted line content is the top (block-start) margin edge,
+  // as the frame is in effect "flipped" for alignment purposes.
+  if (aWritingMode.IsLineInverted()) {
+    return -GetLogicalUsedMargin(aWritingMode).BStart(aWritingMode);
+  }
+  // Otherwise, the bottom margin edge, per CSS2.1's definition of the
+  // 'baseline' value of 'vertical-align'.
+  return BSize(aWritingMode) +
+         GetLogicalUsedMargin(aWritingMode).BEnd(aWritingMode);
+}
+
+const nsFrameList&
+nsFrame::GetChildList(ChildListID aListID) const
+{
+  if (IsAbsoluteContainer() &&
+      aListID == GetAbsoluteListID()) {
+    return GetAbsoluteContainingBlock()->GetChildList();
+  } else {
+    return nsFrameList::EmptyList();
+  }
+}
+
+void
+nsFrame::GetChildLists(nsTArray<ChildList>* aLists) const
+{
+  if (IsAbsoluteContainer()) {
+    nsFrameList absoluteList = GetAbsoluteContainingBlock()->GetChildList();
+    absoluteList.AppendIfNonempty(aLists, GetAbsoluteListID());
+  }
+}
+
+void
+nsIFrame::GetCrossDocChildLists(nsTArray<ChildList>* aLists)
+{
+  nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(this);
+  if (subdocumentFrame) {
+    // Descend into the subdocument
+    nsIFrame* root = subdocumentFrame->GetSubdocumentRootFrame();
+    if (root) {
+      aLists->AppendElement(nsIFrame::ChildList(
+        nsFrameList(root, nsLayoutUtils::GetLastSibling(root)),
+        nsIFrame::kPrincipalList));
+    }
+  }
+
+  GetChildLists(aLists);
+}
+
+Visibility
+nsIFrame::GetVisibility() const
+{
+  if (!(GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED)) {
+    return Visibility::UNTRACKED;
+  }
+
+  bool isSet = false;
+  FrameProperties props = Properties();
+  uint32_t visibleCount = props.Get(VisibilityStateProperty(), &isSet);
+
+  MOZ_ASSERT(isSet, "Should have a VisibilityStateProperty value "
+                    "if NS_FRAME_VISIBILITY_IS_TRACKED is set");
+
+  return visibleCount > 0
+       ? Visibility::APPROXIMATELY_VISIBLE
+       : Visibility::APPROXIMATELY_NONVISIBLE;
+}
+
+void
+nsIFrame::UpdateVisibilitySynchronously()
+{
+  nsIPresShell* presShell = PresContext()->PresShell();
+  if (!presShell) {
+    return;
+  }
+
+  if (presShell->AssumeAllFramesVisible()) {
+    presShell->EnsureFrameInApproximatelyVisibleList(this);
+    return;
+  }
+
+  bool visible = true;
+  nsIFrame* f = GetParent();
+  nsRect rect = GetRectRelativeToSelf();
+  nsIFrame* rectFrame = this;
+  while (f) {
+    nsIScrollableFrame* sf = do_QueryFrame(f);
+    if (sf) {
+      nsRect transformedRect =
+        nsLayoutUtils::TransformFrameRectToAncestor(rectFrame, rect, f);
+      if (!sf->IsRectNearlyVisible(transformedRect)) {
+        visible = false;
+        break;
+      }
+
+      // In this code we're trying to synchronously update *approximate*
+      // visibility. (In the future we may update precise visibility here as
+      // well, which is why the method name does not contain 'approximate'.) The
+      // IsRectNearlyVisible() check above tells us that the rect we're checking
+      // is approximately visible within the scrollframe, but we still need to
+      // ensure that, even if it was scrolled into view, it'd be visible when we
+      // consider the rest of the document. To do that, we move transformedRect
+      // to be contained in the scrollport as best we can (it might not fit) to
+      // pretend that it was scrolled into view.
+      rect = transformedRect.MoveInsideAndClamp(sf->GetScrollPortRect());
+      rectFrame = f;
+    }
+    nsIFrame* parent = f->GetParent();
+    if (!parent) {
+      parent = nsLayoutUtils::GetCrossDocParentFrame(f);
+      if (parent && parent->PresContext()->IsChrome()) {
+        break;
+      }
+    }
+    f = parent;
+  }
+
+  if (visible) {
+    presShell->EnsureFrameInApproximatelyVisibleList(this);
+  } else {
+    presShell->RemoveFrameFromApproximatelyVisibleList(this);
+  }
+}
+
+void
+nsIFrame::EnableVisibilityTracking()
+{
+  if (GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED) {
+    return;  // Nothing to do.
+  }
+
+  FrameProperties props = Properties();
+  MOZ_ASSERT(!props.Has(VisibilityStateProperty()),
+             "Shouldn't have a VisibilityStateProperty value "
+             "if NS_FRAME_VISIBILITY_IS_TRACKED is not set");
+
+  // Add the state bit so we know to track visibility for this frame, and
+  // initialize the frame property.
+  AddStateBits(NS_FRAME_VISIBILITY_IS_TRACKED);
+  props.Set(VisibilityStateProperty(), 0);
+
+  nsIPresShell* presShell = PresContext()->PresShell();
+  if (!presShell) {
+    return;
+  }
+
+  // Schedule a visibility update. This method will virtually always be called
+  // when layout has changed anyway, so it's very unlikely that any additional
+  // visibility updates will be triggered by this, but this way we guarantee
+  // that if this frame is currently visible we'll eventually find out.
+  presShell->ScheduleApproximateFrameVisibilityUpdateSoon();
+}
+
+void
+nsIFrame::DisableVisibilityTracking()
+{
+  if (!(GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED)) {
+    return;  // Nothing to do.
+  }
+
+  bool isSet = false;
+  FrameProperties props = Properties();
+  uint32_t visibleCount = props.Remove(VisibilityStateProperty(), &isSet);
+
+  MOZ_ASSERT(isSet, "Should have a VisibilityStateProperty value "
+                    "if NS_FRAME_VISIBILITY_IS_TRACKED is set");
+
+  RemoveStateBits(NS_FRAME_VISIBILITY_IS_TRACKED);
+
+  if (visibleCount == 0) {
+    return;  // We were nonvisible.
+  }
+
+  // We were visible, so send an OnVisibilityChange() notification.
+  OnVisibilityChange(Visibility::APPROXIMATELY_NONVISIBLE);
+}
+
+void
+nsIFrame::DecApproximateVisibleCount(Maybe<OnNonvisible> aNonvisibleAction
+                                       /* = Nothing() */)
+{
+  MOZ_ASSERT(GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED);
+
+  bool isSet = false;
+  FrameProperties props = Properties();
+  uint32_t visibleCount = props.Get(VisibilityStateProperty(), &isSet);
+
+  MOZ_ASSERT(isSet, "Should have a VisibilityStateProperty value "
+                    "if NS_FRAME_VISIBILITY_IS_TRACKED is set");
+  MOZ_ASSERT(visibleCount > 0, "Frame is already nonvisible and we're "
+                               "decrementing its visible count?");
+
+  visibleCount--;
+  props.Set(VisibilityStateProperty(), visibleCount);
+  if (visibleCount > 0) {
+    return;
+  }
+
+  // We just became nonvisible, so send an OnVisibilityChange() notification.
+  OnVisibilityChange(Visibility::APPROXIMATELY_NONVISIBLE, aNonvisibleAction);
+}
+
+void
+nsIFrame::IncApproximateVisibleCount()
+{
+  MOZ_ASSERT(GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED);
+
+  bool isSet = false;
+  FrameProperties props = Properties();
+  uint32_t visibleCount = props.Get(VisibilityStateProperty(), &isSet);
+
+  MOZ_ASSERT(isSet, "Should have a VisibilityStateProperty value "
+                    "if NS_FRAME_VISIBILITY_IS_TRACKED is set");
+
+  visibleCount++;
+  props.Set(VisibilityStateProperty(), visibleCount);
+  if (visibleCount > 1) {
+    return;
+  }
+
+  // We just became visible, so send an OnVisibilityChange() notification.
+  OnVisibilityChange(Visibility::APPROXIMATELY_VISIBLE);
+}
+
+void
+nsIFrame::OnVisibilityChange(Visibility aNewVisibility,
+                             Maybe<OnNonvisible> aNonvisibleAction
+                               /* = Nothing() */)
+{
+  // XXX(seth): In bug 1218990 we'll implement visibility tracking for CSS
+  // images here.
+}
+
+static nsIFrame*
+GetActiveSelectionFrame(nsPresContext* aPresContext, nsIFrame* aFrame)
+{
+  nsIContent* capturingContent = nsIPresShell::GetCapturingContent();
+  if (capturingContent) {
+    nsIFrame* activeFrame = aPresContext->GetPrimaryFrameFor(capturingContent);
+    return activeFrame ? activeFrame : aFrame;
+  }
+
+  return aFrame;
+}
+
+int16_t
+nsFrame::DisplaySelection(nsPresContext* aPresContext, bool isOkToTurnOn)
+{
+  int16_t selType = nsISelectionController::SELECTION_OFF;
+
+  nsCOMPtr<nsISelectionController> selCon;
+  nsresult result = GetSelectionController(aPresContext, getter_AddRefs(selCon));
+  if (NS_SUCCEEDED(result) && selCon) {
+    result = selCon->GetDisplaySelection(&selType);
+    if (NS_SUCCEEDED(result) && (selType != nsISelectionController::SELECTION_OFF)) {
+      // Check whether style allows selection.
+      bool selectable;
+      IsSelectable(&selectable, nullptr);
+      if (!selectable) {
+        selType = nsISelectionController::SELECTION_OFF;
+        isOkToTurnOn = false;
+      }
+    }
+    if (isOkToTurnOn && (selType == nsISelectionController::SELECTION_OFF)) {
+      selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);
+      selType = nsISelectionController::SELECTION_ON;
+    }
+  }
+  return selType;
+}
+
+class nsDisplaySelectionOverlay : public nsDisplayItem {
+public:
+  nsDisplaySelectionOverlay(nsDisplayListBuilder* aBuilder,
+                            nsFrame* aFrame, int16_t aSelectionValue)
+    : nsDisplayItem(aBuilder, aFrame), mSelectionValue(aSelectionValue) {
+    MOZ_COUNT_CTOR(nsDisplaySelectionOverlay);
+  }
+#ifdef NS_BUILD_REFCNT_LOGGING
+  virtual ~nsDisplaySelectionOverlay() {
+    MOZ_COUNT_DTOR(nsDisplaySelectionOverlay);
+  }
+#endif
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder,
+                     nsRenderingContext* aCtx) override;
+  NS_DISPLAY_DECL_NAME("SelectionOverlay", TYPE_SELECTION_OVERLAY)
+private:
+  int16_t mSelectionValue;
+};
+
+void nsDisplaySelectionOverlay::Paint(nsDisplayListBuilder* aBuilder,
+                                      nsRenderingContext* aCtx)
+{
+  DrawTarget& aDrawTarget = *aCtx->GetDrawTarget();
+
+  LookAndFeel::ColorID colorID;
+  if (mSelectionValue == nsISelectionController::SELECTION_ON) {
+    colorID = LookAndFeel::eColorID_TextSelectBackground;
+  } else if (mSelectionValue == nsISelectionController::SELECTION_ATTENTION) {
+    colorID = LookAndFeel::eColorID_TextSelectBackgroundAttention;
+  } else {
+    colorID = LookAndFeel::eColorID_TextSelectBackgroundDisabled;
+  }
+
+  Color c = Color::FromABGR(LookAndFeel::GetColor(colorID, NS_RGB(255, 255, 255)));
+  c.a = .5;
+  ColorPattern color(ToDeviceColor(c));
+
+  nsIntRect pxRect =
+    mVisibleRect.ToOutsidePixels(mFrame->PresContext()->AppUnitsPerDevPixel());
+  Rect rect(pxRect.x, pxRect.y, pxRect.width, pxRect.height);
+  MaybeSnapToDevicePixels(rect, aDrawTarget, true);
+
+  aDrawTarget.FillRect(rect, color);
+}
+
+/********************************************************
+* Refreshes each content's frame
+*********************************************************/
+
+void
+nsFrame::DisplaySelectionOverlay(nsDisplayListBuilder*   aBuilder,
+                                 nsDisplayList*          aList,
+                                 uint16_t                aContentType)
+{
+  if (!IsSelected() || !IsVisibleForPainting(aBuilder))
+    return;
+    
+  nsPresContext* presContext = PresContext();
+  nsIPresShell *shell = presContext->PresShell();
+  if (!shell)
+    return;
+
+  int16_t displaySelection = shell->GetSelectionFlags();
+  if (!(displaySelection & aContentType))
+    return;
+
+  const nsFrameSelection* frameSelection = GetConstFrameSelection();
+  int16_t selectionValue = frameSelection->GetDisplaySelection();
+
+  if (selectionValue <= nsISelectionController::SELECTION_HIDDEN)
+    return; // selection is hidden or off
+
+  nsIContent *newContent = mContent->GetParent();
+
+  //check to see if we are anonymous content
+  int32_t offset = 0;
+  if (newContent) {
+    // XXXbz there has GOT to be a better way of determining this!
+    offset = newContent->IndexOf(mContent);
+  }
+
+  SelectionDetails *details;
+  //look up to see what selection(s) are on this frame
+  details = frameSelection->LookUpSelection(newContent, offset, 1, false);
+  if (!details)
+    return;
+  
+  bool normal = false;
+  while (details) {
+    if (details->mSelectionType == SelectionType::eNormal) {
+      normal = true;
+    }
+    SelectionDetails *next = details->mNext;
+    delete details;
+    details = next;
+  }
+
+  if (!normal && aContentType == nsISelectionDisplay::DISPLAY_IMAGES) {
+    // Don't overlay an image if it's not in the primary selection.
+    return;
+  }
+
+  aList->AppendNewToTop(new (aBuilder)
+    nsDisplaySelectionOverlay(aBuilder, this, selectionValue));
+}
+
+void
+nsFrame::DisplayOutlineUnconditional(nsDisplayListBuilder*   aBuilder,
+                                     const nsDisplayListSet& aLists)
+{
+  if (StyleOutline()->mOutlineStyle == NS_STYLE_BORDER_STYLE_NONE) {
+    return;
+  }
+
+  aLists.Outlines()->AppendNewToTop(
+    new (aBuilder) nsDisplayOutline(aBuilder, this));
+}
+
+void
+nsFrame::DisplayOutline(nsDisplayListBuilder*   aBuilder,
+                        const nsDisplayListSet& aLists)
+{
+  if (!IsVisibleForPainting(aBuilder))
+    return;
+
+  DisplayOutlineUnconditional(aBuilder, aLists);
+}
+
+void
+nsIFrame::DisplayCaret(nsDisplayListBuilder* aBuilder,
+                       const nsRect& aDirtyRect, nsDisplayList* aList)
+{
+  if (!IsVisibleForPainting(aBuilder))
+    return;
+
+  aList->AppendNewToTop(new (aBuilder) nsDisplayCaret(aBuilder, this));
+}
+
+nscolor
+nsIFrame::GetCaretColorAt(int32_t aOffset)
+{
+  // Use text color.
+  return StyleColor()->mColor;
+}
+
+bool
+nsFrame::DisplayBackgroundUnconditional(nsDisplayListBuilder* aBuilder,
+                                        const nsDisplayListSet& aLists,
+                                        bool aForceBackground)
+{
+  // Here we don't try to detect background propagation. Frames that might
+  // receive a propagated background should just set aForceBackground to
+  // true.
+  if (aBuilder->IsForEventDelivery() || aForceBackground ||
+      !StyleBackground()->IsTransparent() || StyleDisplay()->mAppearance) {
+    return nsDisplayBackgroundImage::AppendBackgroundItemsToTop(
+        aBuilder, this, GetRectRelativeToSelf(), aLists.BorderBackground());
+  }
+  return false;
+}
+
+void
+nsFrame::DisplayBorderBackgroundOutline(nsDisplayListBuilder*   aBuilder,
+                                        const nsDisplayListSet& aLists,
+                                        bool                    aForceBackground)
+{
+  // The visibility check belongs here since child elements have the
+  // opportunity to override the visibility property and display even if
+  // their parent is hidden.
+  if (!IsVisibleForPainting(aBuilder)) {
+    return;
+  }
+
+  nsCSSShadowArray* shadows = StyleEffects()->mBoxShadow;
+  if (shadows && shadows->HasShadowWithInset(false)) {
+    aLists.BorderBackground()->AppendNewToTop(new (aBuilder)
+      nsDisplayBoxShadowOuter(aBuilder, this));
+  }
+
+  bool bgIsThemed = DisplayBackgroundUnconditional(aBuilder, aLists,
+                                                   aForceBackground);
+
+  if (shadows && shadows->HasShadowWithInset(true)) {
+    aLists.BorderBackground()->AppendNewToTop(new (aBuilder)
+      nsDisplayBoxShadowInner(aBuilder, this));
+  }
+
+  // If there's a themed background, we should not create a border item.
+  // It won't be rendered.
+  if (!bgIsThemed && StyleBorder()->HasBorder()) {
+    aLists.BorderBackground()->AppendNewToTop(new (aBuilder)
+      nsDisplayBorder(aBuilder, this));
+  }
+
+  DisplayOutlineUnconditional(aBuilder, aLists);
+}
+
+inline static bool IsSVGContentWithCSSClip(const nsIFrame *aFrame)
+{
+  // The CSS spec says that the 'clip' property only applies to absolutely
+  // positioned elements, whereas the SVG spec says that it applies to SVG
+  // elements regardless of the value of the 'position' property. Here we obey
+  // the CSS spec for outer-<svg> (since that's what we generally do), but
+  // obey the SVG spec for other SVG elements to which 'clip' applies.
+  return (aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT) &&
+          aFrame->GetContent()->IsAnyOfSVGElements(nsGkAtoms::svg,
+                                                   nsGkAtoms::foreignObject);
+}
+
+Maybe<nsRect>
+nsIFrame::GetClipPropClipRect(const nsStyleDisplay* aDisp,
+                              const nsStyleEffects* aEffects,
+                              const nsSize& aSize) const
+{
+  if (!(aEffects->mClipFlags & NS_STYLE_CLIP_RECT) ||
+      !(aDisp->IsAbsolutelyPositioned(this) || IsSVGContentWithCSSClip(this))) {
+    return Nothing();
+  }
+
+  nsRect rect = aEffects->mClip;
+  if (MOZ_LIKELY(StyleBorder()->mBoxDecorationBreak ==
+                   StyleBoxDecorationBreak::Slice)) {
+    // The clip applies to the joined boxes so it's relative the first
+    // continuation.
+    nscoord y = 0;
+    for (nsIFrame* f = GetPrevContinuation(); f; f = f->GetPrevContinuation()) {
+      y += f->GetRect().height;
+    }
+    rect.MoveBy(nsPoint(0, -y));
+  }
+
+  if (NS_STYLE_CLIP_RIGHT_AUTO & aEffects->mClipFlags) {
+    rect.width = aSize.width - rect.x;
+  }
+  if (NS_STYLE_CLIP_BOTTOM_AUTO & aEffects->mClipFlags) {
+    rect.height = aSize.height - rect.y;
+  }
+  return Some(rect);
+}
+
+/**
+ * If the CSS 'overflow' property applies to this frame, and is not
+ * handled by constructing a dedicated nsHTML/XULScrollFrame, set up clipping
+ * for that overflow in aBuilder->ClipState() to clip all containing-block
+ * descendants.
+ */
+static void
+ApplyOverflowClipping(nsDisplayListBuilder* aBuilder,
+                      const nsIFrame* aFrame,
+                      const nsStyleDisplay* aDisp,
+                      DisplayListClipState::AutoClipMultiple& aClipState)
+{
+  // Only -moz-hidden-unscrollable is handled here (and 'hidden' for table
+  // frames, and any non-visible value for blocks in a paginated context).
+  // We allow -moz-hidden-unscrollable to apply to any kind of frame. This
+  // is required by comboboxes which make their display text (an inline frame)
+  // have clipping.
+  if (!nsFrame::ShouldApplyOverflowClipping(aFrame, aDisp)) {
+    return;
+  }
+  nsRect clipRect;
+  bool haveRadii = false;
+  nscoord radii[8];
+  if (aFrame->StyleDisplay()->mOverflowClipBox ==
+        NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX) {
+    clipRect = aFrame->GetPaddingRectRelativeToSelf() +
+      aBuilder->ToReferenceFrame(aFrame);
+    haveRadii = aFrame->GetPaddingBoxBorderRadii(radii);
+  } else {
+    clipRect = aFrame->GetContentRectRelativeToSelf() +
+      aBuilder->ToReferenceFrame(aFrame);
+    // XXX border-radius
+  }
+  aClipState.ClipContainingBlockDescendantsExtra(clipRect, haveRadii ? radii : nullptr);
+}
+
+#ifdef DEBUG
+static void PaintDebugBorder(nsIFrame* aFrame, DrawTarget* aDrawTarget,
+     const nsRect& aDirtyRect, nsPoint aPt)
+{
+  nsRect r(aPt, aFrame->GetSize());
+  int32_t appUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
+  Color blueOrRed(aFrame->HasView() ? Color(0.f, 0.f, 1.f, 1.f) :
+                                      Color(1.f, 0.f, 0.f, 1.f));
+  aDrawTarget->StrokeRect(NSRectToRect(r, appUnitsPerDevPixel),
+                          ColorPattern(ToDeviceColor(blueOrRed)));
+}
+
+static void PaintEventTargetBorder(nsIFrame* aFrame, DrawTarget* aDrawTarget,
+     const nsRect& aDirtyRect, nsPoint aPt)
+{
+  nsRect r(aPt, aFrame->GetSize());
+  int32_t appUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
+  ColorPattern purple(ToDeviceColor(Color(.5f, 0.f, .5f, 1.f)));
+  aDrawTarget->StrokeRect(NSRectToRect(r, appUnitsPerDevPixel), purple);
+}
+
+static void
+DisplayDebugBorders(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
+                    const nsDisplayListSet& aLists) {
+  // Draw a border around the child
+  // REVIEW: From nsContainerFrame::PaintChild
+  if (nsFrame::GetShowFrameBorders() && !aFrame->GetRect().IsEmpty()) {
+    aLists.Outlines()->AppendNewToTop(new (aBuilder)
+        nsDisplayGeneric(aBuilder, aFrame, PaintDebugBorder, "DebugBorder",
+                         nsDisplayItem::TYPE_DEBUG_BORDER));
+  }
+  // Draw a border around the current event target
+  if (nsFrame::GetShowEventTargetFrameBorder() &&
+      aFrame->PresContext()->PresShell()->GetDrawEventTargetFrame() == aFrame) {
+    aLists.Outlines()->AppendNewToTop(new (aBuilder)
+        nsDisplayGeneric(aBuilder, aFrame, PaintEventTargetBorder, "EventTargetBorder",
+                         nsDisplayItem::TYPE_EVENT_TARGET_BORDER));
+  }
+}
+#endif
+
+static bool
+IsScrollFrameActive(nsDisplayListBuilder* aBuilder, nsIScrollableFrame* aScrollableFrame)
+{
+  return aScrollableFrame && aScrollableFrame->IsScrollingActive(aBuilder);
+}
+
+class AutoSaveRestoreContainsBlendMode
+{
+  nsDisplayListBuilder& mBuilder;
+  bool mSavedContainsBlendMode;
+public:
+  explicit AutoSaveRestoreContainsBlendMode(nsDisplayListBuilder& aBuilder)
+    : mBuilder(aBuilder)
+    , mSavedContainsBlendMode(aBuilder.ContainsBlendMode())
+  { }
+
+  ~AutoSaveRestoreContainsBlendMode() {
+    mBuilder.SetContainsBlendMode(mSavedContainsBlendMode);
+  }
+};
+
+static void
+CheckForApzAwareEventHandlers(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
+{
+  nsIContent* content = aFrame->GetContent();
+  if (!content) {
+    return;
+  }
+
+  if (content->IsNodeApzAware()) {
+    aBuilder->SetAncestorHasApzAwareEventHandler(true);
+  }
+}
+
+/**
+ * True if aDescendant participates the context aAncestor participating.
+ */
+static bool
+FrameParticipatesIn3DContext(nsIFrame* aAncestor, nsIFrame* aDescendant) {
+  MOZ_ASSERT(aAncestor != aDescendant);
+  MOZ_ASSERT(aAncestor->Extend3DContext());
+  nsIFrame* frame;
+  for (frame = nsLayoutUtils::GetCrossDocParentFrame(aDescendant);
+       frame && aAncestor != frame;
+       frame = nsLayoutUtils::GetCrossDocParentFrame(frame)) {
+    if (!frame->Extend3DContext()) {
+      return false;
+    }
+  }
+  MOZ_ASSERT(frame == aAncestor);
+  return true;
+}
+
+static bool
+ItemParticipatesIn3DContext(nsIFrame* aAncestor, nsDisplayItem* aItem)
+{
+  nsIFrame* transformFrame;
+  if (aItem->GetType() == nsDisplayItem::TYPE_TRANSFORM) {
+    transformFrame = aItem->Frame();
+  } else if (aItem->GetType() == nsDisplayItem::TYPE_PERSPECTIVE) {
+    transformFrame = static_cast<nsDisplayPerspective*>(aItem)->TransformFrame();
+  } else {
+    return false;
+  }
+  if (aAncestor == transformFrame) {
+    return true;
+  }
+  return FrameParticipatesIn3DContext(aAncestor, transformFrame);
+}
+
+static void
+WrapSeparatorTransform(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
+                       nsRect& aDirtyRect,
+                       nsDisplayList* aSource, nsDisplayList* aTarget,
+                       int aIndex) {
+  if (!aSource->IsEmpty()) {
+    nsDisplayTransform *sepIdItem =
+      new (aBuilder) nsDisplayTransform(aBuilder, aFrame, aSource,
+                                        aDirtyRect, Matrix4x4(), aIndex);
+    sepIdItem->SetNoExtendContext();
+    aTarget->AppendToTop(sepIdItem);
+  }
+}
+
+void
+nsIFrame::BuildDisplayListForStackingContext(nsDisplayListBuilder* aBuilder,
+                                             const nsRect&         aDirtyRect,
+                                             nsDisplayList*        aList) {
+  if (GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)
+    return;
+
+  // Replaced elements have their visibility handled here, because
+  // they're visually atomic
+  if (IsFrameOfType(eReplaced) && !IsVisibleForPainting(aBuilder))
+    return;
+
+  const nsStyleDisplay* disp = StyleDisplay();
+  const nsStyleEffects* effects = StyleEffects();
+  // We can stop right away if this is a zero-opacity stacking context and
+  // we're painting, and we're not animating opacity. Don't do this
+  // if we're going to compute plugin geometry, since opacity-0 plugins
+  // need to have display items built for them.
+  bool needEventRegions =
+    aBuilder->IsBuildingLayerEventRegions() &&
+    StyleUserInterface()->GetEffectivePointerEvents(this) !=
+      NS_STYLE_POINTER_EVENTS_NONE;
+  bool opacityItemForEventsAndPluginsOnly = false;
+  if (effects->mOpacity == 0.0 && aBuilder->IsForPainting() &&
+      !(disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_OPACITY) &&
+      !nsLayoutUtils::HasAnimationOfProperty(this, eCSSProperty_opacity)) {
+    if (needEventRegions ||
+        aBuilder->WillComputePluginGeometry()) {
+      opacityItemForEventsAndPluginsOnly = true;
+    } else {
+      return;
+    }
+  }
+
+  if (disp->mWillChangeBitField != 0) {
+    aBuilder->AddToWillChangeBudget(this, GetSize());
+  }
+
+  bool extend3DContext = Extend3DContext();
+  Maybe<nsDisplayListBuilder::AutoPreserves3DContext> autoPreserves3DContext;
+  if (extend3DContext && !Combines3DTransformWithAncestors()) {
+    // Start a new preserves3d context to keep informations on
+    // nsDisplayListBuilder.
+    autoPreserves3DContext.emplace(aBuilder);
+    // Save dirty rect on the builder to avoid being distorted for
+    // multiple transforms along the chain.
+    aBuilder->SetPreserves3DDirtyRect(aDirtyRect);
+  }
+
+  // For preserves3d, use the dirty rect already installed on the
+  // builder, since aDirtyRect maybe distorted for transforms along
+  // the chain.
+  nsRect dirtyRect = aDirtyRect;
+
+  bool inTransform = aBuilder->IsInTransform();
+  bool isTransformed = IsTransformed();
+  bool hasPerspective = HasPerspective();
+  // reset blend mode so we can keep track if this stacking context needs have
+  // a nsDisplayBlendContainer. Set the blend mode back when the routine exits
+  // so we keep track if the parent stacking context needs a container too.
+  AutoSaveRestoreContainsBlendMode autoRestoreBlendMode(*aBuilder);
+  aBuilder->SetContainsBlendMode(false);
+ 
+  nsRect dirtyRectOutsideTransform = dirtyRect;
+  if (isTransformed) {
+    const nsRect overflow = GetVisualOverflowRectRelativeToSelf();
+    if (nsDisplayTransform::ShouldPrerenderTransformedContent(aBuilder,
+                                                              this)) {
+      dirtyRect = overflow;
+    } else {
+      if (overflow.IsEmpty() && !extend3DContext) {
+        return;
+      }
+
+      // If we're in preserve-3d then grab the dirty rect that was given to the root
+      // and transform using the combined transform.
+      if (Combines3DTransformWithAncestors()) {
+        dirtyRect = aBuilder->GetPreserves3DDirtyRect(this);
+      }
+
+      nsRect untransformedDirtyRect;
+      if (nsDisplayTransform::UntransformRect(dirtyRect, overflow, this,
+            &untransformedDirtyRect)) {
+        dirtyRect = untransformedDirtyRect;
+      } else {
+        NS_WARNING("Unable to untransform dirty rect!");
+        // This should only happen if the transform is singular, in which case nothing is visible anyway
+        dirtyRect.SetEmpty();
+      }
+    }
+    inTransform = true;
+  }
+  bool usingFilter = StyleEffects()->HasFilters();
+  bool usingMask = nsSVGIntegrationUtils::UsingMaskOrClipPathForFrame(this);
+  bool usingSVGEffects = usingFilter || usingMask;
+
+  nsRect dirtyRectOutsideSVGEffects = dirtyRect;
+  nsDisplayList hoistedScrollInfoItemsStorage;
+  if (usingSVGEffects) {
+    dirtyRect =
+      nsSVGIntegrationUtils::GetRequiredSourceForInvalidArea(this, dirtyRect);
+    aBuilder->EnterSVGEffectsContents(&hoistedScrollInfoItemsStorage);
+  }
+
+  // We build an opacity item if it's not going to be drawn by SVG content, or
+  // SVG effects. SVG effects won't handle the opacity if we want an active
+  // layer (for async animations), see
+  // nsSVGIntegrationsUtils::PaintMaskAndClipPath or
+  // nsSVGIntegrationsUtils::PaintFilter.
+  bool useOpacity = HasVisualOpacity() && !nsSVGUtils::CanOptimizeOpacity(this) &&
+                    (!usingSVGEffects || nsDisplayOpacity::NeedsActiveLayer(aBuilder, this));
+  bool useBlendMode = effects->mMixBlendMode != NS_STYLE_BLEND_NORMAL;
+  bool useStickyPosition = disp->mPosition == NS_STYLE_POSITION_STICKY &&
+    IsScrollFrameActive(aBuilder,
+                        nsLayoutUtils::GetNearestScrollableFrame(GetParent(),
+                        nsLayoutUtils::SCROLLABLE_SAME_DOC |
+                        nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN));
+  bool useFixedPosition = nsLayoutUtils::IsFixedPosFrameInDisplayPort(this);
+
+  nsDisplayListBuilder::AutoBuildingDisplayList
+    buildingDisplayList(aBuilder, this, dirtyRect, true);
+
+  // Depending on the effects that are applied to this frame, we can create
+  // multiple container display items and wrap them around our contents.
+  // This enum lists all the potential container display items, in the order
+  // outside to inside.
+  enum class ContainerItemType : uint8_t {
+    eNone = 0,
+    eOwnLayerIfNeeded,
+    eBlendMode,
+    eFixedPosition,
+    eStickyPosition,
+    eOwnLayerForTransformWithRoundedClip,
+    ePerspective,
+    eTransform,
+    eSeparatorTransforms,
+    eOpacity,
+    eFilter,
+    eBlendContainer
+  };
+
+  DisplayListClipState::AutoSaveRestore clipState(aBuilder);
+
+  // If there is a current clip, then depending on the container items we
+  // create, different things can happen to it. Some container items simply
+  // propagate the clip to their children and aren't clipped themselves.
+  // But other container items, especially those that establish a different
+  // geometry for their contents (e.g. transforms), capture the clip on
+  // themselves and unset the clip for their contents. If we create more than
+  // one of those container items, the clip will be captured on the outermost
+  // one and the inner container items will be unclipped.
+  ContainerItemType clipCapturedBy = ContainerItemType::eNone;
+  if (useFixedPosition) {
+    clipCapturedBy = ContainerItemType::eFixedPosition;
+  } else if (useStickyPosition) {
+    clipCapturedBy = ContainerItemType::eStickyPosition;
+  } else if (isTransformed) {
+    if ((hasPerspective || extend3DContext) && clipState.SavedStateHasRoundedCorners()) {
+      // If we're creating an nsDisplayTransform item that is going to combine
+      // its transform with its children (preserve-3d or perspective), then we
+      // can't have an intermediate surface. Mask layers force an intermediate
+      // surface, so if we're going to need both then create a separate
+      // wrapping layer for the mask.
+      clipCapturedBy = ContainerItemType::eOwnLayerForTransformWithRoundedClip;
+    } else if (hasPerspective) {
+      clipCapturedBy = ContainerItemType::ePerspective;
+    } else {
+      clipCapturedBy = ContainerItemType::eTransform;
+    }
+  } else if (usingFilter) {
+    clipCapturedBy = ContainerItemType::eFilter;
+  }
+
+  bool clearClip = false;
+  if (clipCapturedBy != ContainerItemType::eNone) {
+    // We don't need to pass ancestor clipping down to our children;
+    // everything goes inside a display item's child list, and the display
+    // item itself will be clipped.
+    // For transforms we also need to clear ancestor clipping because it's
+    // relative to the wrong display item reference frame anyway.
+    clearClip = true;
+  }
+
+  clipState.EnterStackingContextContents(clearClip);
+
+  nsDisplayListCollection set;
+  {
+    DisplayListClipState::AutoSaveRestore nestedClipState(aBuilder);
+    nsDisplayListBuilder::AutoInTransformSetter
+      inTransformSetter(aBuilder, inTransform);
+    nsDisplayListBuilder::AutoSaveRestorePerspectiveIndex
+      perspectiveIndex(aBuilder, this);
+
+    CheckForApzAwareEventHandlers(aBuilder, this);
+
+    Maybe<nsRect> clipPropClip = GetClipPropClipRect(disp, effects, GetSize());
+    if (clipPropClip) {
+      dirtyRect.IntersectRect(dirtyRect, *clipPropClip);
+      nestedClipState.ClipContentDescendants(
+        *clipPropClip + aBuilder->ToReferenceFrame(this));
+    }
+
+    // extend3DContext also guarantees that applyAbsPosClipping and usingSVGEffects are false
+    // We only modify the preserve-3d rect if we are the top of a preserve-3d heirarchy
+    if (extend3DContext) {
+      // Mark these first so MarkAbsoluteFramesForDisplayList knows if we are
+      // going to be forced to descend into frames.
+      aBuilder->MarkPreserve3DFramesForDisplayList(this);
+    }
+
+    MarkAbsoluteFramesForDisplayList(aBuilder, dirtyRect);
+
+    nsDisplayLayerEventRegions* eventRegions = nullptr;
+    if (aBuilder->IsBuildingLayerEventRegions()) {
+      eventRegions = new (aBuilder) nsDisplayLayerEventRegions(aBuilder, this);
+      eventRegions->AddFrame(aBuilder, this);
+      aBuilder->SetLayerEventRegions(eventRegions);
+    }
+    aBuilder->AdjustWindowDraggingRegion(this);
+    BuildDisplayList(aBuilder, dirtyRect, set);
+    if (eventRegions) {
+      // If the event regions item ended up empty, throw it away rather than
+      // adding it to the display list.
+      if (!eventRegions->IsEmpty()) {
+        set.BorderBackground()->AppendToBottom(eventRegions);
+      } else {
+        aBuilder->SetLayerEventRegions(nullptr);
+        eventRegions->~nsDisplayLayerEventRegions();
+        eventRegions = nullptr;
+      }
+    }
+  }
+
+  if (aBuilder->IsBackgroundOnly()) {
+    set.BlockBorderBackgrounds()->DeleteAll();
+    set.Floats()->DeleteAll();
+    set.Content()->DeleteAll();
+    set.PositionedDescendants()->DeleteAll();
+    set.Outlines()->DeleteAll();
+  }
+
+  // Sort PositionedDescendants() in CSS 'z-order' order.  The list is already
+  // in content document order and SortByZOrder is a stable sort which
+  // guarantees that boxes produced by the same element are placed together
+  // in the sort. Consider a position:relative inline element that breaks
+  // across lines and has absolutely positioned children; all the abs-pos
+  // children should be z-ordered after all the boxes for the position:relative
+  // element itself.
+  set.PositionedDescendants()->SortByZOrder();
+
+  nsDisplayList resultList;
+  // Now follow the rules of http://www.w3.org/TR/CSS21/zindex.html
+  // 1,2: backgrounds and borders
+  resultList.AppendToTop(set.BorderBackground());
+  // 3: negative z-index children.
+  for (;;) {
+    nsDisplayItem* item = set.PositionedDescendants()->GetBottom();
+    if (item && item->ZIndex() < 0) {
+      set.PositionedDescendants()->RemoveBottom();
+      resultList.AppendToTop(item);
+      continue;
+    }
+    break;
+  }
+  // 4: block backgrounds
+  resultList.AppendToTop(set.BlockBorderBackgrounds());
+  // 5: floats
+  resultList.AppendToTop(set.Floats());
+  // 7: general content
+  resultList.AppendToTop(set.Content());
+  // 7.5: outlines, in content tree order. We need to sort by content order
+  // because an element with outline that breaks and has children with outline
+  // might have placed child outline items between its own outline items.
+  // The element's outline items need to all come before any child outline
+  // items.
+  nsIContent* content = GetContent();
+  if (!content) {
+    content = PresContext()->Document()->GetRootElement();
+  }
+  if (content) {
+    set.Outlines()->SortByContentOrder(content);
+  }
+#ifdef DEBUG
+  DisplayDebugBorders(aBuilder, this, set);
+#endif
+  resultList.AppendToTop(set.Outlines());
+  // 8, 9: non-negative z-index children
+  resultList.AppendToTop(set.PositionedDescendants());
+
+  // Get the scroll clip to use for the container items that we create here.
+  // If we cleared the clip, and we create multiple container items, then the
+  // items we create before we restore the clip will have a different scroll
+  // clip from the items we create after we restore the clip.
+  const DisplayItemScrollClip* containerItemScrollClip =
+    aBuilder->ClipState().CurrentAncestorScrollClipForStackingContextContents();
+
+  /* If adding both a nsDisplayBlendContainer and a nsDisplayBlendMode to the
+   * same list, the nsDisplayBlendContainer should be added first. This only
+   * happens when the element creating this stacking context has mix-blend-mode
+   * and also contains a child which has mix-blend-mode.
+   * The nsDisplayBlendContainer must be added to the list first, so it does not
+   * isolate the containing element blending as well.
+   */
+
+  if (aBuilder->ContainsBlendMode()) {
+    DisplayListClipState::AutoSaveRestore blendContainerClipState(aBuilder);
+    blendContainerClipState.Clear();
+    resultList.AppendNewToTop(
+      nsDisplayBlendContainer::CreateForMixBlendMode(aBuilder, this, &resultList,
+                                                     containerItemScrollClip));
+  }
+
+  /* If there are any SVG effects, wrap the list up in an SVG effects item
+   * (which also handles CSS group opacity). Note that we create an SVG effects
+   * item even if resultList is empty, since a filter can produce graphical
+   * output even if the element being filtered wouldn't otherwise do so.
+   */
+  if (usingSVGEffects) {
+    MOZ_ASSERT(usingFilter ||usingMask,
+               "Beside filter & mask/clip-path, what else effect do we have?");
+
+    if (clipCapturedBy == ContainerItemType::eFilter) {
+      clipState.ExitStackingContextContents(&containerItemScrollClip);
+    }
+    // Revert to the post-filter dirty rect.
+    buildingDisplayList.SetDirtyRect(dirtyRectOutsideSVGEffects);
+
+    // Skip all filter effects while generating glyph mask.
+    if (usingFilter && !aBuilder->IsForGenerateGlyphMask()) {
+      // If we are going to create a mask display item, handle opacity effect
+      // in that mask display item; Otherwise, take care of opacity in this
+      // filter display item.
+      bool handleOpacity = !usingMask && !useOpacity;
+
+      /* List now emptied, so add the new list to the top. */
+      resultList.AppendNewToTop(
+        new (aBuilder) nsDisplayFilter(aBuilder, this, &resultList,
+                                       handleOpacity));
+    }
+
+    if (usingMask) {
+      DisplayListClipState::AutoSaveRestore maskClipState(aBuilder);
+      maskClipState.Clear();
+      /* List now emptied, so add the new list to the top. */
+      resultList.AppendNewToTop(
+          new (aBuilder) nsDisplayMask(aBuilder, this, &resultList,
+                                       !useOpacity, containerItemScrollClip));
+    }
+
+    // Also add the hoisted scroll info items. We need those for APZ scrolling
+    // because nsDisplayMask items can't build active layers.
+    aBuilder->ExitSVGEffectsContents();
+    resultList.AppendToTop(&hoistedScrollInfoItemsStorage);
+  }
+
+  /* If the list is non-empty and there is CSS group opacity without SVG
+   * effects, wrap it up in an opacity item.
+   */
+  if (useOpacity && !resultList.IsEmpty()) {
+    // Don't clip nsDisplayOpacity items. We clip their descendants instead.
+    // The clip we would set on an element with opacity would clip
+    // all descendant content, but some should not be clipped.
+    DisplayListClipState::AutoSaveRestore opacityClipState(aBuilder);
+    opacityClipState.Clear();
+    resultList.AppendNewToTop(
+        new (aBuilder) nsDisplayOpacity(aBuilder, this, &resultList,
+                                        containerItemScrollClip, opacityItemForEventsAndPluginsOnly));
+  }
+
+  /* If we're going to apply a transformation and don't have preserve-3d set, wrap
+   * everything in an nsDisplayTransform. If there's nothing in the list, don't add
+   * anything.
+   *
+   * For the preserve-3d case we want to individually wrap every child in the list with
+   * a separate nsDisplayTransform instead. When the child is already an nsDisplayTransform,
+   * we can skip this step, as the computed transform will already include our own.
+   *
+   * We also traverse into sublists created by nsDisplayWrapList, so that we find all the
+   * correct children.
+   */
+  if (isTransformed && !resultList.IsEmpty() && extend3DContext) {
+    // Install dummy nsDisplayTransform as a leaf containing
+    // descendants not participating this 3D rendering context.
+    nsDisplayList nonparticipants;
+    nsDisplayList participants;
+    int index = 1;
+
+    while (nsDisplayItem* item = resultList.RemoveBottom()) {
+      if (ItemParticipatesIn3DContext(this, item) && !item->GetClip().HasClip()) {
+        // The frame of this item participates the same 3D context.
+        WrapSeparatorTransform(aBuilder, this, dirtyRect,
+                               &nonparticipants, &participants, index++);
+        participants.AppendToTop(item);
+      } else {
+        // The frame of the item doesn't participate the current
+        // context, or has no transform.
+        //
+        // For items participating but not transformed, they are add
+        // to nonparticipants to get a separator layer for handling
+        // clips, if there is, on an intermediate surface.
+        // \see ContainerLayer::DefaultComputeEffectiveTransforms().
+        nonparticipants.AppendToTop(item);
+      }
+    }
+    WrapSeparatorTransform(aBuilder, this, dirtyRect,
+                           &nonparticipants, &participants, index++);
+    resultList.AppendToTop(&participants);
+  }
+
+  if (isTransformed && !resultList.IsEmpty()) {
+    if (clipCapturedBy == ContainerItemType::eTransform) {
+      // Restore clip state now so nsDisplayTransform is clipped properly.
+      clipState.ExitStackingContextContents(&containerItemScrollClip);
+    }
+    // Revert to the dirtyrect coming in from the parent, without our transform
+    // taken into account.
+    buildingDisplayList.SetDirtyRect(dirtyRectOutsideTransform);
+    // Revert to the outer reference frame and offset because all display
+    // items we create from now on are outside the transform.
+    nsPoint toOuterReferenceFrame;
+    const nsIFrame* outerReferenceFrame = this;
+    if (this != aBuilder->RootReferenceFrame()) {
+      outerReferenceFrame =
+        aBuilder->FindReferenceFrameFor(GetParent(), &toOuterReferenceFrame);
+    }
+    buildingDisplayList.SetReferenceFrameAndCurrentOffset(outerReferenceFrame,
+      GetOffsetToCrossDoc(outerReferenceFrame));
+
+    bool isFullyVisible =
+      dirtyRectOutsideSVGEffects.Contains(GetVisualOverflowRectRelativeToSelf());
+    nsDisplayTransform *transformItem =
+      new (aBuilder) nsDisplayTransform(aBuilder, this,
+                                          &resultList, dirtyRect, 0,
+                                          isFullyVisible);
+    resultList.AppendNewToTop(transformItem);
+
+    if (hasPerspective) {
+      if (clipCapturedBy == ContainerItemType::ePerspective) {
+        clipState.ExitStackingContextContents(&containerItemScrollClip);
+      }
+      resultList.AppendNewToTop(
+        new (aBuilder) nsDisplayPerspective(
+          aBuilder, this,
+          GetContainingBlock()->GetContent()->GetPrimaryFrame(), &resultList));
+    }
+  }
+
+  if (clipCapturedBy == ContainerItemType::eOwnLayerForTransformWithRoundedClip) {
+    clipState.ExitStackingContextContents(&containerItemScrollClip);
+    resultList.AppendNewToTop(
+      new (aBuilder) nsDisplayOwnLayer(aBuilder, this, &resultList, 0,
+                                       mozilla::layers::FrameMetrics::NULL_SCROLL_ID,
+                                       0.0f, /* aForceActive = */ false));
+  }
+
+  /* If we have sticky positioning, wrap it in a sticky position item.
+   */
+  if (useFixedPosition) {
+    if (clipCapturedBy == ContainerItemType::eFixedPosition) {
+      clipState.ExitStackingContextContents(&containerItemScrollClip);
+    }
+    resultList.AppendNewToTop(
+        new (aBuilder) nsDisplayFixedPosition(aBuilder, this, &resultList));
+  } else if (useStickyPosition) {
+    if (clipCapturedBy == ContainerItemType::eStickyPosition) {
+      clipState.ExitStackingContextContents(&containerItemScrollClip);
+    }
+    resultList.AppendNewToTop(
+        new (aBuilder) nsDisplayStickyPosition(aBuilder, this, &resultList));
+  }
+
+  /* If there's blending, wrap up the list in a blend-mode item. Note
+   * that opacity can be applied before blending as the blend color is
+   * not affected by foreground opacity (only background alpha).
+   */
+
+  if (useBlendMode && !resultList.IsEmpty()) {
+    DisplayListClipState::AutoSaveRestore mixBlendClipState(aBuilder);
+    mixBlendClipState.Clear();
+    resultList.AppendNewToTop(
+        new (aBuilder) nsDisplayBlendMode(aBuilder, this, &resultList,
+                                          effects->mMixBlendMode,
+                                          containerItemScrollClip));
+  }
+
+  CreateOwnLayerIfNeeded(aBuilder, &resultList);
+
+  aList->AppendToTop(&resultList);
+}
+
+static nsDisplayItem*
+WrapInWrapList(nsDisplayListBuilder* aBuilder,
+               nsIFrame* aFrame, nsDisplayList* aList,
+               const DisplayItemScrollClip* aScrollClip)
+{
+  nsDisplayItem* item = aList->GetBottom();
+  if (!item) {
+    return nullptr;
+  }
+
+  // For perspective items we want to treat the 'frame' as being the transform
+  // frame that created it. This stops the transform frame from wrapping another
+  // nsDisplayWrapList around it (with mismatching reference frames), but still
+  // makes the perspective frame create one (so we have an atomic entry for z-index
+  // sorting).
+  nsIFrame *itemFrame = item->Frame();
+  if (item->GetType() == nsDisplayItem::TYPE_PERSPECTIVE) {
+    itemFrame = static_cast<nsDisplayPerspective*>(item)->TransformFrame();
+  }
+
+  if (item->GetAbove() || itemFrame != aFrame) {
+    return new (aBuilder) nsDisplayWrapList(aBuilder, aFrame, aList, aScrollClip);
+  }
+  aList->RemoveBottom();
+  return item;
+}
+
+void
+nsIFrame::BuildDisplayListForChild(nsDisplayListBuilder*   aBuilder,
+                                   nsIFrame*               aChild,
+                                   const nsRect&           aDirtyRect,
+                                   const nsDisplayListSet& aLists,
+                                   uint32_t                aFlags) {
+  // If painting is restricted to just the background of the top level frame,
+  // then we have nothing to do here.
+  if (aBuilder->IsBackgroundOnly())
+    return;
+
+  if (aBuilder->IsForGenerateGlyphMask() ||
+      aBuilder->IsForPaintingSelectionBG()) {
+    if (nsGkAtoms::textFrame != aChild->GetType() && aChild->IsLeaf()) {
+      return;
+    }
+  }
+
+  nsIFrame* child = aChild;
+  if (child->GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)
+    return;
+
+  bool isSVG = (child->GetStateBits() & NS_FRAME_SVG_LAYOUT);
+
+  // true if this is a real or pseudo stacking context
+  bool pseudoStackingContext =
+    (aFlags & DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT) != 0;
+  if (!isSVG &&
+      (aFlags & DISPLAY_CHILD_INLINE) &&
+      !child->IsFrameOfType(eLineParticipant)) {
+    // child is a non-inline frame in an inline context, i.e.,
+    // it acts like inline-block or inline-table. Therefore it is a
+    // pseudo-stacking-context.
+    pseudoStackingContext = true;
+  }
+
+  // dirty rect in child-relative coordinates
+  nsRect dirty = aDirtyRect - child->GetOffsetTo(this);
+
+  nsIAtom* childType = child->GetType();
+  nsDisplayListBuilder::OutOfFlowDisplayData* savedOutOfFlowData = nullptr;
+  bool isPlaceholder = false;
+  if (childType == nsGkAtoms::placeholderFrame) {
+    isPlaceholder = true;
+    nsPlaceholderFrame* placeholder = static_cast<nsPlaceholderFrame*>(child);
+    child = placeholder->GetOutOfFlowFrame();
+    NS_ASSERTION(child, "No out of flow frame?");
+    // If 'child' is a pushed float then it's owned by a block that's not an
+    // ancestor of the placeholder, and it will be painted by that block and
+    // should not be painted through the placeholder.
+    if (!child || nsLayoutUtils::IsPopup(child) ||
+        (child->GetStateBits() & NS_FRAME_IS_PUSHED_FLOAT))
+      return;
+    MOZ_ASSERT(child->GetStateBits() & NS_FRAME_OUT_OF_FLOW);
+    // If the out-of-flow frame is in the top layer, the viewport frame
+    // will paint it. Skip it here. Note that, only out-of-flow frames
+    // with this property should be skipped, because non-HTML elements
+    // may stop their children from being out-of-flow. Those frames
+    // should still be handled in the normal in-flow path.
+    if (placeholder->GetStateBits() & PLACEHOLDER_FOR_TOPLAYER) {
+      return;
+    }
+    // Make sure that any attempt to use childType below is disappointed. We
+    // could call GetType again but since we don't currently need it, let's
+    // avoid the virtual call.
+    childType = nullptr;
+    // Recheck NS_FRAME_TOO_DEEP_IN_FRAME_TREE
+    if (child->GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)
+      return;
+    savedOutOfFlowData = nsDisplayListBuilder::GetOutOfFlowData(child);
+    if (savedOutOfFlowData) {
+      dirty = savedOutOfFlowData->mDirtyRect;
+    } else {
+      // The out-of-flow frame did not intersect the dirty area. We may still
+      // need to traverse into it, since it may contain placeholders we need
+      // to enter to reach other out-of-flow frames that are visible.
+      dirty.SetEmpty();
+    }
+    pseudoStackingContext = true;
+  }
+
+  NS_ASSERTION(childType != nsGkAtoms::placeholderFrame,
+               "Should have dealt with placeholders already");
+  if (aBuilder->GetSelectedFramesOnly() &&
+      child->IsLeaf() &&
+      !aChild->IsSelected()) {
+    return;
+  }
+
+  if (aBuilder->GetIncludeAllOutOfFlows() &&
+      (child->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
+    dirty = child->GetVisualOverflowRect();
+  } else if (!(child->GetStateBits() & NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO)) {
+    // No need to descend into child to catch placeholders for visible
+    // positioned stuff. So see if we can short-circuit frame traversal here.
+
+    // We can stop if child's frame subtree's intersection with the
+    // dirty area is empty.
+    // If the child is a scrollframe that we want to ignore, then we need
+    // to descend into it because its scrolled child may intersect the dirty
+    // area even if the scrollframe itself doesn't.
+    // There are cases where the "ignore scroll frame" on the builder is not set
+    // correctly, and so we additionally want to catch cases where the child is
+    // a root scrollframe and we are ignoring scrolling on the viewport.
+    nsIPresShell* shell = PresContext()->PresShell();
+    bool keepDescending = child == aBuilder->GetIgnoreScrollFrame() ||
+        (shell->IgnoringViewportScrolling() && child == shell->GetRootScrollFrame());
+    if (!keepDescending) {
+      nsRect childDirty;
+      if (!childDirty.IntersectRect(dirty, child->GetVisualOverflowRect()))
+        return;
+      // Usually we could set dirty to childDirty now but there's no
+      // benefit, and it can be confusing. It can especially confuse
+      // situations where we're going to ignore a scrollframe's clipping;
+      // we wouldn't want to clip the dirty area to the scrollframe's
+      // bounds in that case.
+    }
+  }
+
+  // XXX need to have inline-block and inline-table set pseudoStackingContext
+  
+  const nsStyleDisplay* ourDisp = StyleDisplay();
+  // REVIEW: Taken from nsBoxFrame::Paint
+  // Don't paint our children if the theme object is a leaf.
+  if (IsThemed(ourDisp) &&
+      !PresContext()->GetTheme()->WidgetIsContainer(ourDisp->mAppearance))
+    return;
+
+  // Since we're now sure that we're adding this frame to the display list
+  // (which means we're painting it, modulo occlusion), mark it as visible
+  // within the displayport.
+  if (aBuilder->IsPaintingToWindow() && child->TrackingVisibility()) {
+    child->PresContext()->PresShell()->EnsureFrameInApproximatelyVisibleList(child);
+  }
+
+  // Child is composited if it's transformed, partially transparent, or has
+  // SVG effects or a blend mode..
+  const nsStyleDisplay* disp = child->StyleDisplay();
+  const nsStyleEffects* effects = child->StyleEffects();
+  const nsStylePosition* pos = child->StylePosition();
+  bool isVisuallyAtomic = child->HasOpacity()
+    || child->IsTransformed()
+    // strictly speaking, 'perspective' doesn't require visual atomicity,
+    // but the spec says it acts like the rest of these
+    || disp->mChildPerspective.GetUnit() == eStyleUnit_Coord
+    || effects->mMixBlendMode != NS_STYLE_BLEND_NORMAL
+    || nsSVGIntegrationUtils::UsingEffectsForFrame(child);
+
+  bool isPositioned = disp->IsAbsPosContainingBlock(child);
+  bool isStackingContext =
+    (isPositioned && (disp->IsPositionForcingStackingContext() ||
+                      pos->mZIndex.GetUnit() == eStyleUnit_Integer)) ||
+     (disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_STACKING_CONTEXT) ||
+     disp->mIsolation != NS_STYLE_ISOLATION_AUTO ||
+     isVisuallyAtomic || (aFlags & DISPLAY_CHILD_FORCE_STACKING_CONTEXT);
+
+  if (isVisuallyAtomic || isPositioned || (!isSVG && disp->IsFloating(child)) ||
+      ((effects->mClipFlags & NS_STYLE_CLIP_RECT) &&
+       IsSVGContentWithCSSClip(child)) ||
+       disp->mIsolation != NS_STYLE_ISOLATION_AUTO ||
+       (disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_STACKING_CONTEXT) ||
+      (aFlags & DISPLAY_CHILD_FORCE_STACKING_CONTEXT)) {
+    // If you change this, also change IsPseudoStackingContextFromStyle()
+    pseudoStackingContext = true;
+  }
+  NS_ASSERTION(!isStackingContext || pseudoStackingContext,
+               "Stacking contexts must also be pseudo-stacking-contexts");
+
+  nsDisplayListBuilder::AutoBuildingDisplayList
+    buildingForChild(aBuilder, child, dirty, pseudoStackingContext);
+  DisplayListClipState::AutoClipMultiple clipState(aBuilder);
+  CheckForApzAwareEventHandlers(aBuilder, child);
+
+  if (savedOutOfFlowData) {
+    aBuilder->SetBuildingInvisibleItems(false);
+
+    clipState.SetClipForContainingBlockDescendants(
+      &savedOutOfFlowData->mContainingBlockClip);
+    clipState.SetScrollClipForContainingBlockDescendants(aBuilder,
+      savedOutOfFlowData->mContainingBlockScrollClip);
+  } else if (GetStateBits() & NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO &&
+             isPlaceholder) {
+    NS_ASSERTION(dirty.IsEmpty(), "should have empty dirty rect");
+    // Every item we build from now until we descent into an out of flow that
+    // does have saved out of flow data should be invisible. This state gets
+    // restored when AutoBuildingDisplayList gets out of scope.
+    aBuilder->SetBuildingInvisibleItems(true);
+
+    // If we have nested out-of-flow frames and the outer one isn't visible
+    // then we won't have stored clip data for it. We can just clear the clip
+    // instead since we know we won't render anything, and the inner out-of-flow
+    // frame will setup the correct clip for itself.
+    clipState.SetClipForContainingBlockDescendants(nullptr);
+    clipState.SetScrollClipForContainingBlockDescendants(aBuilder, nullptr);
+  }
+
+  // Setup clipping for the parent's overflow:-moz-hidden-unscrollable,
+  // or overflow:hidden on elements that don't support scrolling (and therefore
+  // don't create nsHTML/XULScrollFrame). This clipping needs to not clip
+  // anything directly rendered by the parent, only the rendering of its
+  // children.
+  // Don't use overflowClip to restrict the dirty rect, since some of the
+  // descendants may not be clipped by it. Even if we end up with unnecessary
+  // display items, they'll be pruned during ComputeVisibility.
+  nsIFrame* parent = child->GetParent();
+  const nsStyleDisplay* parentDisp =
+    parent == this ? ourDisp : parent->StyleDisplay();
+  ApplyOverflowClipping(aBuilder, parent, parentDisp, clipState);
+
+  nsDisplayList list;
+  nsDisplayList extraPositionedDescendants;
+  if (isStackingContext) {
+    if (effects->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {
+      aBuilder->SetContainsBlendMode(true);
+    }
+    // True stacking context.
+    // For stacking contexts, BuildDisplayListForStackingContext handles
+    // clipping and MarkAbsoluteFramesForDisplayList.
+    child->BuildDisplayListForStackingContext(aBuilder, dirty, &list);
+    aBuilder->DisplayCaret(child, dirty, &list);
+  } else {
+    Maybe<nsRect> clipPropClip =
+      child->GetClipPropClipRect(disp, effects, child->GetSize());
+    if (clipPropClip) {
+      dirty.IntersectRect(dirty, *clipPropClip);
+      clipState.ClipContentDescendants(
+        *clipPropClip + aBuilder->ToReferenceFrame(child));
+    }
+
+    child->MarkAbsoluteFramesForDisplayList(aBuilder, dirty);
+
+    if (aBuilder->IsBuildingLayerEventRegions()) {
+      // If this frame has a different animated geometry root than its parent,
+      // make sure we accumulate event regions for its layer.
+      if (buildingForChild.IsAnimatedGeometryRoot() || isPositioned) {
+        nsDisplayLayerEventRegions* eventRegions =
+          new (aBuilder) nsDisplayLayerEventRegions(aBuilder, child);
+        eventRegions->AddFrame(aBuilder, child);
+        aBuilder->SetLayerEventRegions(eventRegions);
+
+        if (isPositioned) {
+          // We need this nsDisplayLayerEventRegions to be sorted with the positioned
+          // elements as positioned elements will be sorted on top of normal elements
+          list.AppendNewToTop(eventRegions);
+        } else {
+          aLists.BorderBackground()->AppendNewToTop(eventRegions);
+        }
+      } else {
+        nsDisplayLayerEventRegions* eventRegions = aBuilder->GetLayerEventRegions();
+        if (eventRegions) {
+          eventRegions->AddFrame(aBuilder, child);
+        }
+      }
+    }
+
+    if (!pseudoStackingContext) {
+      // THIS IS THE COMMON CASE.
+      // Not a pseudo or real stacking context. Do the simple thing and
+      // return early.
+
+      aBuilder->AdjustWindowDraggingRegion(child);
+      child->BuildDisplayList(aBuilder, dirty, aLists);
+      aBuilder->DisplayCaret(child, dirty, aLists.Content());
+#ifdef DEBUG
+      DisplayDebugBorders(aBuilder, child, aLists);
+#endif
+      return;
+    }
+
+    // A pseudo-stacking context (e.g., a positioned element with z-index auto).
+    // We allow positioned descendants of the child to escape to our parent
+    // stacking context's positioned descendant list, because they might be
+    // z-index:non-auto
+    nsDisplayListCollection pseudoStack;
+    aBuilder->AdjustWindowDraggingRegion(child);
+    child->BuildDisplayList(aBuilder, dirty, pseudoStack);
+    aBuilder->DisplayCaret(child, dirty, pseudoStack.Content());
+
+    list.AppendToTop(pseudoStack.BorderBackground());
+    list.AppendToTop(pseudoStack.BlockBorderBackgrounds());
+    list.AppendToTop(pseudoStack.Floats());
+    list.AppendToTop(pseudoStack.Content());
+    list.AppendToTop(pseudoStack.Outlines());
+    extraPositionedDescendants.AppendToTop(pseudoStack.PositionedDescendants());
+#ifdef DEBUG
+    DisplayDebugBorders(aBuilder, child, aLists);
+#endif
+  }
+
+  buildingForChild.RestoreBuildingInvisibleItemsValue();
+ 
+  // Clear clip rect for the construction of the items below. Since we're
+  // clipping all their contents, they themselves don't need to be clipped.
+  clipState.Clear();
+
+  const DisplayItemScrollClip* containerItemScrollClip =
+    aBuilder->ClipState().CurrentAncestorScrollClipForStackingContextContents();
+
+  if (isPositioned || isVisuallyAtomic ||
+      (aFlags & DISPLAY_CHILD_FORCE_STACKING_CONTEXT)) {
+    // Genuine stacking contexts, and positioned pseudo-stacking-contexts,
+    // go in this level.
+    if (!list.IsEmpty()) {
+      nsDisplayItem* item = WrapInWrapList(aBuilder, child, &list, containerItemScrollClip);
+      if (isSVG) {
+        aLists.Content()->AppendNewToTop(item);
+      } else {
+        aLists.PositionedDescendants()->AppendNewToTop(item);
+      }
+    }
+  } else if (!isSVG && disp->IsFloating(child)) {
+    if (!list.IsEmpty()) {
+      aLists.Floats()->AppendNewToTop(WrapInWrapList(aBuilder, child, &list, containerItemScrollClip));
+    }
+  } else {
+    aLists.Content()->AppendToTop(&list);
+  }
+  // We delay placing the positioned descendants of positioned frames to here,
+  // because in the absence of z-index this is the correct order for them.
+  // This doesn't affect correctness because the positioned descendants list
+  // is sorted by z-order and content in BuildDisplayListForStackingContext,
+  // but it means that sort routine needs to do less work.
+  aLists.PositionedDescendants()->AppendToTop(&extraPositionedDescendants);
+}
+
+void
+nsIFrame::MarkAbsoluteFramesForDisplayList(nsDisplayListBuilder* aBuilder,
+                                           const nsRect& aDirtyRect)
+{
+  if (IsAbsoluteContainer()) {
+    aBuilder->MarkFramesForDisplayList(this, GetAbsoluteContainingBlock()->GetChildList(), aDirtyRect);
+  }
+}
+
+nsresult  
+nsFrame::GetContentForEvent(WidgetEvent* aEvent,
+                            nsIContent** aContent)
+{
+  nsIFrame* f = nsLayoutUtils::GetNonGeneratedAncestor(this);
+  *aContent = f->GetContent();
+  NS_IF_ADDREF(*aContent);
+  return NS_OK;
+}
+
+void
+nsFrame::FireDOMEvent(const nsAString& aDOMEventName, nsIContent *aContent)
+{
+  nsIContent* target = aContent ? aContent : mContent;
+
+  if (target) {
+    RefPtr<AsyncEventDispatcher> asyncDispatcher =
+      new AsyncEventDispatcher(target, aDOMEventName, true, false);
+    DebugOnly<nsresult> rv = asyncDispatcher->PostDOMEvent();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncEventDispatcher failed to dispatch");
+  }
+}
+
+nsresult
+nsFrame::HandleEvent(nsPresContext* aPresContext, 
+                     WidgetGUIEvent* aEvent,
+                     nsEventStatus* aEventStatus)
+{
+
+  if (aEvent->mMessage == eMouseMove) {
+    // XXX If the second argument of HandleDrag() is WidgetMouseEvent,
+    //     the implementation becomes simpler.
+    return HandleDrag(aPresContext, aEvent, aEventStatus);
+  }
+
+  if ((aEvent->mClass == eMouseEventClass &&
+       aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) ||
+      aEvent->mClass == eTouchEventClass) {
+    if (aEvent->mMessage == eMouseDown || aEvent->mMessage == eTouchStart) {
+      HandlePress(aPresContext, aEvent, aEventStatus);
+    } else if (aEvent->mMessage == eMouseUp || aEvent->mMessage == eTouchEnd) {
+      HandleRelease(aPresContext, aEvent, aEventStatus);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFrame::GetDataForTableSelection(const nsFrameSelection* aFrameSelection,
+                                  nsIPresShell* aPresShell,
+                                  WidgetMouseEvent* aMouseEvent, 
+                                  nsIContent** aParentContent,
+                                  int32_t* aContentOffset,
+                                  int32_t* aTarget)
+{
+  if (!aFrameSelection || !aPresShell || !aMouseEvent || !aParentContent || !aContentOffset || !aTarget)
+    return NS_ERROR_NULL_POINTER;
+
+  *aParentContent = nullptr;
+  *aContentOffset = 0;
+  *aTarget = 0;
+
+  int16_t displaySelection = aPresShell->GetSelectionFlags();
+
+  bool selectingTableCells = aFrameSelection->GetTableCellSelection();
+
+  // DISPLAY_ALL means we're in an editor.
+  // If already in cell selection mode, 
+  //  continue selecting with mouse drag or end on mouse up,
+  //  or when using shift key to extend block of cells
+  //  (Mouse down does normal selection unless Ctrl/Cmd is pressed)
+  bool doTableSelection =
+     displaySelection == nsISelectionDisplay::DISPLAY_ALL && selectingTableCells &&
+     (aMouseEvent->mMessage == eMouseMove ||
+      (aMouseEvent->mMessage == eMouseUp &&
+       aMouseEvent->button == WidgetMouseEvent::eLeftButton) ||
+      aMouseEvent->IsShift());
+
+  if (!doTableSelection)
+  {  
+    // In Browser, special 'table selection' key must be pressed for table selection
+    // or when just Shift is pressed and we're already in table/cell selection mode
+#ifdef XP_MACOSX
+    doTableSelection = aMouseEvent->IsMeta() || (aMouseEvent->IsShift() && selectingTableCells);
+#else
+    doTableSelection = aMouseEvent->IsControl() || (aMouseEvent->IsShift() && selectingTableCells);
+#endif
+  }
+  if (!doTableSelection) 
+    return NS_OK;
+
+  // Get the cell frame or table frame (or parent) of the current content node
+  nsIFrame *frame = this;
+  bool foundCell = false;
+  bool foundTable = false;
+
+  // Get the limiting node to stop parent frame search
+  nsIContent* limiter = aFrameSelection->GetLimiter();
+
+  // If our content node is an ancestor of the limiting node,
+  // we should stop the search right now.
+  if (limiter && nsContentUtils::ContentIsDescendantOf(limiter, GetContent()))
+    return NS_OK;
+
+  //We don't initiate row/col selection from here now,
+  //  but we may in future
+  //bool selectColumn = false;
+  //bool selectRow = false;
+  
+  while (frame)
+  {
+    // Check for a table cell by querying to a known CellFrame interface
+    nsITableCellLayout *cellElement = do_QueryFrame(frame);
+    if (cellElement)
+    {
+      foundCell = true;
+      //TODO: If we want to use proximity to top or left border
+      //      for row and column selection, this is the place to do it
+      break;
+    }
+    else
+    {
+      // If not a cell, check for table
+      // This will happen when starting frame is the table or child of a table,
+      //  such as a row (we were inbetween cells or in table border)
+      nsTableWrapperFrame *tableFrame = do_QueryFrame(frame);
+      if (tableFrame)
+      {
+        foundTable = true;
+        //TODO: How can we select row when along left table edge
+        //  or select column when along top edge?
+        break;
+      } else {
+        frame = frame->GetParent();
+        // Stop if we have hit the selection's limiting content node
+        if (frame && frame->GetContent() == limiter)
+          break;
+      }
+    }
+  }
+  // We aren't in a cell or table
+  if (!foundCell && !foundTable) return NS_OK;
+
+  nsIContent* tableOrCellContent = frame->GetContent();
+  if (!tableOrCellContent) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIContent> parentContent = tableOrCellContent->GetParent();
+  if (!parentContent) return NS_ERROR_FAILURE;
+
+  int32_t offset = parentContent->IndexOf(tableOrCellContent);
+  // Not likely?
+  if (offset < 0) return NS_ERROR_FAILURE;
+
+  // Everything is OK -- set the return values
+  parentContent.forget(aParentContent);
+
+  *aContentOffset = offset;
+
+#if 0
+  if (selectRow)
+    *aTarget = nsISelectionPrivate::TABLESELECTION_ROW;
+  else if (selectColumn)
+    *aTarget = nsISelectionPrivate::TABLESELECTION_COLUMN;
+  else 
+#endif
+  if (foundCell)
+    *aTarget = nsISelectionPrivate::TABLESELECTION_CELL;
+  else if (foundTable)
+    *aTarget = nsISelectionPrivate::TABLESELECTION_TABLE;
+
+  return NS_OK;
+}
+
+nsresult
+nsFrame::IsSelectable(bool* aSelectable, StyleUserSelect* aSelectStyle) const
+{
+  if (!aSelectable) //it's ok if aSelectStyle is null
+    return NS_ERROR_NULL_POINTER;
+
+  // Like 'visibility', we must check all the parents: if a parent
+  // is not selectable, none of its children is selectable.
+  //
+  // The -moz-all value acts similarly: if a frame has 'user-select:-moz-all',
+  // all its children are selectable, even those with 'user-select:none'.
+  //
+  // As a result, if 'none' and '-moz-all' are not present in the frame hierarchy,
+  // aSelectStyle returns the first style that is not AUTO. If these values
+  // are present in the frame hierarchy, aSelectStyle returns the style of the
+  // topmost parent that has either 'none' or '-moz-all'.
+  //
+  // The -moz-text value acts as a way to override an ancestor's all/-moz-all value.
+  //
+  // For instance, if the frame hierarchy is:
+  //    AUTO     -> _MOZ_ALL  -> NONE -> TEXT,      the returned value is ALL
+  //    AUTO     -> _MOZ_ALL  -> NONE -> _MOZ_TEXT, the returned value is TEXT.
+  //    TEXT     -> NONE      -> AUTO -> _MOZ_ALL,  the returned value is TEXT
+  //    _MOZ_ALL -> TEXT      -> AUTO -> AUTO,      the returned value is ALL
+  //    _MOZ_ALL -> _MOZ_TEXT -> AUTO -> AUTO,      the returned value is TEXT.
+  //    AUTO     -> CELL      -> TEXT -> AUTO,      the returned value is TEXT
+  //
+  StyleUserSelect selectStyle  = StyleUserSelect::Auto;
+  nsIFrame* frame              = const_cast<nsFrame*>(this);
+  bool containsEditable        = false;
+
+  while (frame) {
+    const nsStyleUIReset* userinterface = frame->StyleUIReset();
+    switch (userinterface->mUserSelect) {
+      case StyleUserSelect::All:
+      case StyleUserSelect::MozAll:
+      {
+        // override the previous values
+        if (selectStyle != StyleUserSelect::MozText) {
+          selectStyle = userinterface->mUserSelect;
+        }
+        nsIContent* frameContent = frame->GetContent();
+        containsEditable = frameContent &&
+          frameContent->EditableDescendantCount() > 0;
+        break;
+      }
+      default:
+        // otherwise return the first value which is not 'auto'
+        if (selectStyle == StyleUserSelect::Auto) {
+          selectStyle = userinterface->mUserSelect;
+        }
+        break;
+    }
+    frame = nsLayoutUtils::GetParentOrPlaceholderFor(frame);
+  }
+
+  // convert internal values to standard values
+  if (selectStyle == StyleUserSelect::Auto ||
+      selectStyle == StyleUserSelect::MozText) {
+    selectStyle = StyleUserSelect::Text;
+  } else if (selectStyle == StyleUserSelect::MozAll) {
+    selectStyle = StyleUserSelect::All;
+  }
+
+  // If user tries to select all of a non-editable content,
+  // prevent selection if it contains editable content.
+  bool allowSelection = true;
+  if (selectStyle == StyleUserSelect::All) {
+    allowSelection = !containsEditable;
+  }
+
+  // return stuff
+  if (aSelectStyle) {
+    *aSelectStyle = selectStyle;
+  }
+
+  if (mState & NS_FRAME_GENERATED_CONTENT) {
+    *aSelectable = false;
+  } else {
+    *aSelectable = allowSelection && (selectStyle != StyleUserSelect::None);
+  }
+
+  return NS_OK;
+}
+
+/**
+  * Handles the Mouse Press Event for the frame
+ */
+NS_IMETHODIMP
+nsFrame::HandlePress(nsPresContext* aPresContext, 
+                     WidgetGUIEvent* aEvent,
+                     nsEventStatus* aEventStatus)
+{
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+  if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
+    return NS_OK;
+  }
+
+  NS_ENSURE_ARG_POINTER(aEvent);
+  if (aEvent->mClass == eTouchEventClass) {
+    return NS_OK;
+  }
+
+  //We often get out of sync state issues with mousedown events that
+  //get interrupted by alerts/dialogs.
+  //Check with the ESM to see if we should process this one
+  if (!aPresContext->EventStateManager()->EventStatusOK(aEvent)) 
+    return NS_OK;
+
+  nsresult rv;
+  nsIPresShell *shell = aPresContext->GetPresShell();
+  if (!shell)
+    return NS_ERROR_FAILURE;
+
+  // if we are in Navigator and the click is in a draggable node, we don't want
+  // to start selection because we don't want to interfere with a potential
+  // drag of said node and steal all its glory.
+  int16_t isEditor = shell->GetSelectionFlags();
+  //weaaak. only the editor can display frame selection not just text and images
+  isEditor = isEditor == nsISelectionDisplay::DISPLAY_ALL;
+
+  WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+
+  if (!mouseEvent->IsAlt()) {
+    for (nsIContent* content = mContent; content;
+         content = content->GetParent()) {
+      if (nsContentUtils::ContentIsDraggable(content) &&
+          !content->IsEditable()) {
+        // coordinate stuff is the fix for bug #55921
+        if ((mRect - GetPosition()).Contains(
+              nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, this))) {
+          return NS_OK;
+        }
+      }
+    }
+  }
+
+  // check whether style allows selection
+  // if not, don't tell selection the mouse event even occurred.  
+  bool    selectable;
+  StyleUserSelect selectStyle;
+  rv = IsSelectable(&selectable, &selectStyle);
+  if (NS_FAILED(rv)) return rv;
+  
+  // check for select: none
+  if (!selectable)
+    return NS_OK;
+
+  // When implementing StyleUserSelect::Element, StyleUserSelect::Elements and
+  // StyleUserSelect::Toggle, need to change this logic
+  bool useFrameSelection = (selectStyle == StyleUserSelect::Text);
+
+  // If the mouse is dragged outside the nearest enclosing scrollable area
+  // while making a selection, the area will be scrolled. To do this, capture
+  // the mouse on the nearest scrollable frame. If there isn't a scrollable
+  // frame, or something else is already capturing the mouse, there's no
+  // reason to capture.
+  bool hasCapturedContent = false;
+  if (!nsIPresShell::GetCapturingContent()) {
+    nsIScrollableFrame* scrollFrame =
+      nsLayoutUtils::GetNearestScrollableFrame(this,
+        nsLayoutUtils::SCROLLABLE_SAME_DOC |
+        nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+    if (scrollFrame) {
+      nsIFrame* capturingFrame = do_QueryFrame(scrollFrame);
+      nsIPresShell::SetCapturingContent(capturingFrame->GetContent(),
+                                        CAPTURE_IGNOREALLOWED);
+      hasCapturedContent = true;
+    }
+  }
+
+  // XXX This is screwy; it really should use the selection frame, not the
+  // event frame
+  const nsFrameSelection* frameselection = nullptr;
+  if (useFrameSelection)
+    frameselection = GetConstFrameSelection();
+  else
+    frameselection = shell->ConstFrameSelection();
+
+  if (!frameselection || frameselection->GetDisplaySelection() == nsISelectionController::SELECTION_OFF)
+    return NS_OK;//nothing to do we cannot affect selection from here
+
+#ifdef XP_MACOSX
+  if (mouseEvent->IsControl())
+    return NS_OK;//short circuit. hard coded for mac due to time restraints.
+  bool control = mouseEvent->IsMeta();
+#else
+  bool control = mouseEvent->IsControl();
+#endif
+
+  RefPtr<nsFrameSelection> fc = const_cast<nsFrameSelection*>(frameselection);
+  if (mouseEvent->mClickCount > 1) {
+    // These methods aren't const but can't actually delete anything,
+    // so no need for nsWeakFrame.
+    fc->SetDragState(true);
+    fc->SetMouseDoubleDown(true);
+    return HandleMultiplePress(aPresContext, mouseEvent, aEventStatus, control);
+  }
+
+  nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, this);
+  ContentOffsets offsets = GetContentOffsetsFromPoint(pt, SKIP_HIDDEN);
+
+  if (!offsets.content)
+    return NS_ERROR_FAILURE;
+
+  // On touchables devices, touch the screen is usually a pan action,
+  // so let's reposition the caret if needed but do not select text
+  // if the touch did not happen over an editable element.  Otherwise,
+  // let the user move the caret by tapping and dragging.
+  if (!offsets.content->IsEditable() &&
+      Preferences::GetBool("browser.ignoreNativeFrameTextSelection", false)) {
+    // On touchables devices, mouse events are generated if the gesture is a tap.
+    // Such events are never going to generate a drag action, so let's release
+    // captured content if any.
+    if (hasCapturedContent) {
+      nsIPresShell::SetCapturingContent(nullptr, 0);
+    }
+
+    return fc->HandleClick(offsets.content, offsets.StartOffset(),
+                           offsets.EndOffset(), false, false,
+                           offsets.associate);
+  }
+
+  // Let Ctrl/Cmd+mouse down do table selection instead of drag initiation
+  nsCOMPtr<nsIContent>parentContent;
+  int32_t  contentOffset;
+  int32_t target;
+  rv = GetDataForTableSelection(frameselection, shell, mouseEvent,
+                                getter_AddRefs(parentContent), &contentOffset,
+                                &target);
+  if (NS_SUCCEEDED(rv) && parentContent)
+  {
+    fc->SetDragState(true);
+    return fc->HandleTableSelection(parentContent, contentOffset, target,
+                                    mouseEvent);
+  }
+
+  fc->SetDelayedCaretData(0);
+
+  // Check if any part of this frame is selected, and if the
+  // user clicked inside the selected region. If so, we delay
+  // starting a new selection since the user may be trying to
+  // drag the selected region to some other app.
+
+  SelectionDetails *details = 0;
+  if (GetContent()->IsSelectionDescendant())
+  {
+    bool inSelection = false;
+    details = frameselection->LookUpSelection(offsets.content, 0,
+        offsets.EndOffset(), false);
+
+    //
+    // If there are any details, check to see if the user clicked
+    // within any selected region of the frame.
+    //
+
+    SelectionDetails *curDetail = details;
+
+    while (curDetail)
+    {
+      //
+      // If the user clicked inside a selection, then just
+      // return without doing anything. We will handle placing
+      // the caret later on when the mouse is released. We ignore
+      // the spellcheck, find and url formatting selections.
+      //
+      if (curDetail->mSelectionType != SelectionType::eSpellCheck &&
+          curDetail->mSelectionType != SelectionType::eFind &&
+          curDetail->mSelectionType != SelectionType::eURLSecondary &&
+          curDetail->mSelectionType != SelectionType::eURLStrikeout &&
+          curDetail->mStart <= offsets.StartOffset() &&
+          offsets.EndOffset() <= curDetail->mEnd)
+      {
+        inSelection = true;
+      }
+
+      SelectionDetails *nextDetail = curDetail->mNext;
+      delete curDetail;
+      curDetail = nextDetail;
+    }
+
+    if (inSelection) {
+      fc->SetDragState(false);
+      fc->SetDelayedCaretData(mouseEvent);
+      return NS_OK;
+    }
+  }
+
+  fc->SetDragState(true);
+
+  // Do not touch any nsFrame members after this point without adding
+  // weakFrame checks.
+  rv = fc->HandleClick(offsets.content, offsets.StartOffset(),
+                       offsets.EndOffset(), mouseEvent->IsShift(), control,
+                       offsets.associate);
+
+  if (NS_FAILED(rv))
+    return rv;
+
+  if (offsets.offset != offsets.secondaryOffset)
+    fc->MaintainSelection();
+
+  if (isEditor && !mouseEvent->IsShift() &&
+      (offsets.EndOffset() - offsets.StartOffset()) == 1)
+  {
+    // A single node is selected and we aren't extending an existing
+    // selection, which means the user clicked directly on an object (either
+    // -moz-user-select: all or a non-text node without children).
+    // Therefore, disable selection extension during mouse moves.
+    // XXX This is a bit hacky; shouldn't editor be able to deal with this?
+    fc->SetDragState(false);
+  }
+
+  return rv;
+}
+
+/*
+ * SelectByTypeAtPoint
+ *
+ * Search for selectable content at point and attempt to select
+ * based on the start and end selection behaviours.
+ *
+ * @param aPresContext Presentation context
+ * @param aPoint Point at which selection will occur. Coordinates
+ * should be relaitve to this frame.
+ * @param aBeginAmountType, aEndAmountType Selection behavior, see
+ * nsIFrame for definitions.
+ * @param aSelectFlags Selection flags defined in nsFame.h.
+ * @return success or failure at finding suitable content to select.
+ */
+nsresult
+nsFrame::SelectByTypeAtPoint(nsPresContext* aPresContext,
+                             const nsPoint& aPoint,
+                             nsSelectionAmount aBeginAmountType,
+                             nsSelectionAmount aEndAmountType,
+                             uint32_t aSelectFlags)
+{
+  NS_ENSURE_ARG_POINTER(aPresContext);
+
+  // No point in selecting if selection is turned off
+  if (DisplaySelection(aPresContext) == nsISelectionController::SELECTION_OFF)
+    return NS_OK;
+
+  ContentOffsets offsets = GetContentOffsetsFromPoint(aPoint, SKIP_HIDDEN);
+  if (!offsets.content)
+    return NS_ERROR_FAILURE;
+
+  int32_t offset;
+  const nsFrameSelection* frameSelection =
+    PresContext()->GetPresShell()->ConstFrameSelection();
+  nsIFrame* theFrame = frameSelection->
+    GetFrameForNodeOffset(offsets.content, offsets.offset,
+                          offsets.associate, &offset);
+  if (!theFrame)
+    return NS_ERROR_FAILURE;
+
+  nsFrame* frame = static_cast<nsFrame*>(theFrame);
+  return frame->PeekBackwardAndForward(aBeginAmountType, aEndAmountType, offset,
+                                       aBeginAmountType != eSelectWord,
+                                       aSelectFlags);
+}
+
+/**
+  * Multiple Mouse Press -- line or paragraph selection -- for the frame.
+  * Wouldn't it be nice if this didn't have to be hardwired into Frame code?
+ */
+NS_IMETHODIMP
+nsFrame::HandleMultiplePress(nsPresContext* aPresContext,
+                             WidgetGUIEvent* aEvent,
+                             nsEventStatus* aEventStatus,
+                             bool aControlHeld)
+{
+  NS_ENSURE_ARG_POINTER(aEvent);
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+
+  if (nsEventStatus_eConsumeNoDefault == *aEventStatus ||
+      DisplaySelection(aPresContext) == nsISelectionController::SELECTION_OFF) {
+    return NS_OK;
+  }
+
+  // Find out whether we're doing line or paragraph selection.
+  // If browser.triple_click_selects_paragraph is true, triple-click selects paragraph.
+  // Otherwise, triple-click selects line, and quadruple-click selects paragraph
+  // (on platforms that support quadruple-click).
+  nsSelectionAmount beginAmount, endAmount;
+  WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+  if (!mouseEvent) {
+    return NS_OK;
+  }
+
+  if (mouseEvent->mClickCount == 4) {
+    beginAmount = endAmount = eSelectParagraph;
+  } else if (mouseEvent->mClickCount == 3) {
+    if (Preferences::GetBool("browser.triple_click_selects_paragraph")) {
+      beginAmount = endAmount = eSelectParagraph;
+    } else {
+      beginAmount = eSelectBeginLine;
+      endAmount = eSelectEndLine;
+    }
+  } else if (mouseEvent->mClickCount == 2) {
+    // We only want inline frames; PeekBackwardAndForward dislikes blocks
+    beginAmount = endAmount = eSelectWord;
+  } else {
+    return NS_OK;
+  }
+
+  nsPoint relPoint =
+    nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, this);
+  return SelectByTypeAtPoint(aPresContext, relPoint, beginAmount, endAmount,
+                             (aControlHeld ? SELECT_ACCUMULATE : 0));
+}
+
+nsresult
+nsFrame::PeekBackwardAndForward(nsSelectionAmount aAmountBack,
+                                nsSelectionAmount aAmountForward,
+                                int32_t aStartPos,
+                                bool aJumpLines,
+                                uint32_t aSelectFlags)
+{
+  nsIFrame* baseFrame = this;
+  int32_t baseOffset = aStartPos;
+  nsresult rv;
+
+  if (aAmountBack == eSelectWord) {
+    // To avoid selecting the previous word when at start of word,
+    // first move one character forward.
+    nsPeekOffsetStruct pos(eSelectCharacter,
+                           eDirNext,
+                           aStartPos,
+                           nsPoint(0, 0),
+                           aJumpLines,
+                           true,  //limit on scrolled views
+                           false,
+                           false,
+                           false);
+    rv = PeekOffset(&pos);
+    if (NS_SUCCEEDED(rv)) {
+      baseFrame = pos.mResultFrame;
+      baseOffset = pos.mContentOffset;
+    }
+  }
+
+  // Use peek offset one way then the other:
+  nsPeekOffsetStruct startpos(aAmountBack,
+                              eDirPrevious,
+                              baseOffset,
+                              nsPoint(0, 0),
+                              aJumpLines,
+                              true,  //limit on scrolled views
+                              false,
+                              false,
+                              false);
+  rv = baseFrame->PeekOffset(&startpos);
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsPeekOffsetStruct endpos(aAmountForward,
+                            eDirNext,
+                            aStartPos,
+                            nsPoint(0, 0),
+                            aJumpLines,
+                            true,  //limit on scrolled views
+                            false,
+                            false,
+                            false);
+  rv = PeekOffset(&endpos);
+  if (NS_FAILED(rv))
+    return rv;
+
+  // Keep frameSelection alive.
+  RefPtr<nsFrameSelection> frameSelection = GetFrameSelection();
+
+  rv = frameSelection->HandleClick(startpos.mResultContent,
+                                   startpos.mContentOffset, startpos.mContentOffset,
+                                   false, (aSelectFlags & SELECT_ACCUMULATE),
+                                   CARET_ASSOCIATE_AFTER);
+  if (NS_FAILED(rv))
+    return rv;
+
+  rv = frameSelection->HandleClick(endpos.mResultContent,
+                                   endpos.mContentOffset, endpos.mContentOffset,
+                                   true, false,
+                                   CARET_ASSOCIATE_BEFORE);
+  if (NS_FAILED(rv))
+    return rv;
+
+  // maintain selection
+  return frameSelection->MaintainSelection(aAmountBack);
+}
+
+NS_IMETHODIMP nsFrame::HandleDrag(nsPresContext* aPresContext, 
+                                  WidgetGUIEvent* aEvent,
+                                  nsEventStatus* aEventStatus)
+{
+  MOZ_ASSERT(aEvent->mClass == eMouseEventClass,
+             "HandleDrag can only handle mouse event");
+
+  RefPtr<nsFrameSelection> frameselection = GetFrameSelection();
+  bool mouseDown = frameselection->GetDragState();
+  if (!mouseDown) {
+    return NS_OK;
+  }
+
+  nsIFrame* scrollbar =
+    nsLayoutUtils::GetClosestFrameOfType(this, nsGkAtoms::scrollbarFrame);
+  if (!scrollbar) {
+    // XXX Do we really need to exclude non-selectable content here?
+    // GetContentOffsetsFromPoint can handle it just fine, although some
+    // other stuff might not like it.
+    // NOTE: DisplaySelection() returns SELECTION_OFF for non-selectable frames.
+    if (DisplaySelection(aPresContext) == nsISelectionController::SELECTION_OFF) {
+      return NS_OK;
+    }
+  }
+
+  frameselection->StopAutoScrollTimer();
+
+  // Check if we are dragging in a table cell
+  nsCOMPtr<nsIContent> parentContent;
+  int32_t contentOffset;
+  int32_t target;
+  WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+  nsCOMPtr<nsIPresShell> presShell = aPresContext->PresShell();
+  nsresult result;
+  result = GetDataForTableSelection(frameselection, presShell, mouseEvent,
+                                    getter_AddRefs(parentContent),
+                                    &contentOffset, &target);      
+
+  nsWeakFrame weakThis = this;
+  if (NS_SUCCEEDED(result) && parentContent) {
+    frameselection->HandleTableSelection(parentContent, contentOffset, target,
+                                         mouseEvent);
+  } else {
+    nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, this);
+    frameselection->HandleDrag(this, pt);
+  }
+
+  // The frameselection object notifies selection listeners synchronously above
+  // which might have killed us.
+  if (!weakThis.IsAlive()) {
+    return NS_OK;
+  }
+
+  // get the nearest scrollframe
+  nsIScrollableFrame* scrollFrame =
+    nsLayoutUtils::GetNearestScrollableFrame(this,
+        nsLayoutUtils::SCROLLABLE_SAME_DOC |
+        nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+
+  if (scrollFrame) {
+    nsIFrame* capturingFrame = scrollFrame->GetScrolledFrame();
+    if (capturingFrame) {
+      nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent,
+                                                                capturingFrame);
+      frameselection->StartAutoScrollTimer(capturingFrame, pt, 30);
+    }
+  }
+
+  return NS_OK;
+}
+
+/**
+ * This static method handles part of the nsFrame::HandleRelease in a way
+ * which doesn't rely on the nsFrame object to stay alive.
+ */
+static nsresult
+HandleFrameSelection(nsFrameSelection*         aFrameSelection,
+                     nsIFrame::ContentOffsets& aOffsets,
+                     bool                      aHandleTableSel,
+                     int32_t                   aContentOffsetForTableSel,
+                     int32_t                   aTargetForTableSel,
+                     nsIContent*               aParentContentForTableSel,
+                     WidgetGUIEvent*           aEvent,
+                     nsEventStatus*            aEventStatus)
+{
+  if (!aFrameSelection) {
+    return NS_OK;
+  }
+
+  nsresult rv = NS_OK;
+
+  if (nsEventStatus_eConsumeNoDefault != *aEventStatus) {
+    if (!aHandleTableSel) {
+      if (!aOffsets.content || !aFrameSelection->HasDelayedCaretData()) {
+        return NS_ERROR_FAILURE;
+      }
+
+      // We are doing this to simulate what we would have done on HandlePress.
+      // We didn't do it there to give the user an opportunity to drag
+      // the text, but since they didn't drag, we want to place the
+      // caret.
+      // However, we'll use the mouse position from the release, since:
+      //  * it's easier
+      //  * that's the normal click position to use (although really, in
+      //    the normal case, small movements that don't count as a drag
+      //    can do selection)
+      aFrameSelection->SetDragState(true);
+
+      rv = aFrameSelection->HandleClick(aOffsets.content,
+                                        aOffsets.StartOffset(),
+                                        aOffsets.EndOffset(),
+                                        aFrameSelection->IsShiftDownInDelayedCaretData(),
+                                        false,
+                                        aOffsets.associate);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+    } else if (aParentContentForTableSel) {
+      aFrameSelection->SetDragState(false);
+      rv = aFrameSelection->HandleTableSelection(
+                              aParentContentForTableSel,
+                              aContentOffsetForTableSel,
+                              aTargetForTableSel,
+                              aEvent->AsMouseEvent());
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+    }
+    aFrameSelection->SetDelayedCaretData(0);
+  }
+
+  aFrameSelection->SetDragState(false);
+  aFrameSelection->StopAutoScrollTimer();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsFrame::HandleRelease(nsPresContext* aPresContext,
+                                     WidgetGUIEvent* aEvent,
+                                     nsEventStatus* aEventStatus)
+{
+  if (aEvent->mClass != eMouseEventClass) {
+    return NS_OK;
+  }
+
+  nsIFrame* activeFrame = GetActiveSelectionFrame(aPresContext, this);
+
+  nsCOMPtr<nsIContent> captureContent = nsIPresShell::GetCapturingContent();
+
+  // We can unconditionally stop capturing because
+  // we should never be capturing when the mouse button is up
+  nsIPresShell::SetCapturingContent(nullptr, 0);
+
+  bool selectionOff =
+    (DisplaySelection(aPresContext) == nsISelectionController::SELECTION_OFF);
+
+  RefPtr<nsFrameSelection> frameselection;
+  ContentOffsets offsets;
+  nsCOMPtr<nsIContent> parentContent;
+  int32_t contentOffsetForTableSel = 0;
+  int32_t targetForTableSel = 0;
+  bool handleTableSelection = true;
+
+  if (!selectionOff) {
+    frameselection = GetFrameSelection();
+    if (nsEventStatus_eConsumeNoDefault != *aEventStatus && frameselection) {
+      // Check if the frameselection recorded the mouse going down.
+      // If not, the user must have clicked in a part of the selection.
+      // Place the caret before continuing!
+
+      if (frameselection->MouseDownRecorded()) {
+        nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, this);
+        offsets = GetContentOffsetsFromPoint(pt, SKIP_HIDDEN);
+        handleTableSelection = false;
+      } else {
+        GetDataForTableSelection(frameselection, PresContext()->PresShell(),
+                                 aEvent->AsMouseEvent(),
+                                 getter_AddRefs(parentContent),
+                                 &contentOffsetForTableSel,
+                                 &targetForTableSel);
+      }
+    }
+  }
+
+  // We might be capturing in some other document and the event just happened to
+  // trickle down here. Make sure that document's frame selection is notified.
+  // Note, this may cause the current nsFrame object to be deleted, bug 336592.
+  RefPtr<nsFrameSelection> frameSelection;
+  if (activeFrame != this &&
+      static_cast<nsFrame*>(activeFrame)->DisplaySelection(activeFrame->PresContext())
+        != nsISelectionController::SELECTION_OFF) {
+      frameSelection = activeFrame->GetFrameSelection();
+  }
+
+  // Also check the selection of the capturing content which might be in a
+  // different document.
+  if (!frameSelection && captureContent) {
+    nsIDocument* doc = captureContent->GetUncomposedDoc();
+    if (doc) {
+      nsIPresShell* capturingShell = doc->GetShell();
+      if (capturingShell && capturingShell != PresContext()->GetPresShell()) {
+        frameSelection = capturingShell->FrameSelection();
+      }
+    }
+  }
+
+  if (frameSelection) {
+    frameSelection->SetDragState(false);
+    frameSelection->StopAutoScrollTimer();
+    nsIScrollableFrame* scrollFrame =
+      nsLayoutUtils::GetNearestScrollableFrame(this,
+        nsLayoutUtils::SCROLLABLE_SAME_DOC |
+        nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+    if (scrollFrame) {
+      // Perform any additional scrolling needed to maintain CSS snap point
+      // requirements when autoscrolling is over.
+      scrollFrame->ScrollSnap();
+    }
+  }
+
+  // Do not call any methods of the current object after this point!!!
+  // The object is perhaps dead!
+
+  return selectionOff
+    ? NS_OK
+    : HandleFrameSelection(frameselection, offsets, handleTableSelection,
+                           contentOffsetForTableSel, targetForTableSel,
+                           parentContent, aEvent, aEventStatus);
+}
+
+struct MOZ_STACK_CLASS FrameContentRange {
+  FrameContentRange(nsIContent* aContent, int32_t aStart, int32_t aEnd) :
+    content(aContent), start(aStart), end(aEnd) { }
+  nsCOMPtr<nsIContent> content;
+  int32_t start;
+  int32_t end;
+};
+
+// Retrieve the content offsets of a frame
+static FrameContentRange GetRangeForFrame(nsIFrame* aFrame) {
+  nsCOMPtr<nsIContent> content, parent;
+  content = aFrame->GetContent();
+  if (!content) {
+    NS_WARNING("Frame has no content");
+    return FrameContentRange(nullptr, -1, -1);
+  }
+  nsIAtom* type = aFrame->GetType();
+  if (type == nsGkAtoms::textFrame) {
+    int32_t offset, offsetEnd;
+    aFrame->GetOffsets(offset, offsetEnd);
+    return FrameContentRange(content, offset, offsetEnd);
+  }
+  if (type == nsGkAtoms::brFrame) {
+    parent = content->GetParent();
+    int32_t beginOffset = parent->IndexOf(content);
+    return FrameContentRange(parent, beginOffset, beginOffset);
+  }
+  // Loop to deal with anonymous content, which has no index; this loop
+  // probably won't run more than twice under normal conditions
+  do {
+    parent  = content->GetParent();
+    if (parent) {
+      int32_t beginOffset = parent->IndexOf(content);
+      if (beginOffset >= 0)
+        return FrameContentRange(parent, beginOffset, beginOffset + 1);
+      content = parent;
+    }
+  } while (parent);
+
+  // The root content node must act differently
+  return FrameContentRange(content, 0, content->GetChildCount());
+}
+
+// The FrameTarget represents the closest frame to a point that can be selected
+// The frame is the frame represented, frameEdge says whether one end of the
+// frame is the result (in which case different handling is needed), and
+// afterFrame says which end is repersented if frameEdge is true
+struct FrameTarget {
+  FrameTarget(nsIFrame* aFrame, bool aFrameEdge, bool aAfterFrame,
+              bool aEmptyBlock = false) :
+    frame(aFrame), frameEdge(aFrameEdge), afterFrame(aAfterFrame),
+    emptyBlock(aEmptyBlock) { }
+  static FrameTarget Null() {
+    return FrameTarget(nullptr, false, false);
+  }
+  bool IsNull() {
+    return !frame;
+  }
+  nsIFrame* frame;
+  bool frameEdge;
+  bool afterFrame;
+  bool emptyBlock;
+};
+
+// See function implementation for information
+static FrameTarget GetSelectionClosestFrame(nsIFrame* aFrame, nsPoint aPoint,
+                                            uint32_t aFlags);
+
+static bool SelfIsSelectable(nsIFrame* aFrame, uint32_t aFlags)
+{
+  if ((aFlags & nsIFrame::SKIP_HIDDEN) &&
+      !aFrame->StyleVisibility()->IsVisible()) {
+    return false;
+  }
+  return !aFrame->IsGeneratedContentFrame() &&
+    aFrame->StyleUIReset()->mUserSelect != StyleUserSelect::None;
+}
+
+static bool SelectionDescendToKids(nsIFrame* aFrame) {
+  StyleUserSelect style = aFrame->StyleUIReset()->mUserSelect;
+  nsIFrame* parent = aFrame->GetParent();
+  // If we are only near (not directly over) then don't traverse
+  // frames with independent selection (e.g. text and list controls)
+  // unless we're already inside such a frame (see bug 268497).  Note that this
+  // prevents any of the users of this method from entering form controls.
+  // XXX We might want some way to allow using the up-arrow to go into a form
+  // control, but the focus didn't work right anyway; it'd probably be enough
+  // if the left and right arrows could enter textboxes (which I don't believe
+  // they can at the moment)
+  return !aFrame->IsGeneratedContentFrame() &&
+         style != StyleUserSelect::All  &&
+         style != StyleUserSelect::None &&
+         ((parent->GetStateBits() & NS_FRAME_INDEPENDENT_SELECTION) ||
+          !(aFrame->GetStateBits() & NS_FRAME_INDEPENDENT_SELECTION));
+}
+
+static FrameTarget GetSelectionClosestFrameForChild(nsIFrame* aChild,
+                                                    nsPoint aPoint,
+                                                    uint32_t aFlags)
+{
+  nsIFrame* parent = aChild->GetParent();
+  if (SelectionDescendToKids(aChild)) {
+    nsPoint pt = aPoint - aChild->GetOffsetTo(parent);
+    return GetSelectionClosestFrame(aChild, pt, aFlags);
+  }
+  return FrameTarget(aChild, false, false);
+}
+
+// When the cursor needs to be at the beginning of a block, it shouldn't be
+// before the first child.  A click on a block whose first child is a block
+// should put the cursor in the child.  The cursor shouldn't be between the
+// blocks, because that's not where it's expected.
+// Note that this method is guaranteed to succeed.
+static FrameTarget DrillDownToSelectionFrame(nsIFrame* aFrame,
+                                             bool aEndFrame, uint32_t aFlags) {
+  if (SelectionDescendToKids(aFrame)) {
+    nsIFrame* result = nullptr;
+    nsIFrame *frame = aFrame->PrincipalChildList().FirstChild();
+    if (!aEndFrame) {
+      while (frame && (!SelfIsSelectable(frame, aFlags) ||
+                        frame->IsEmpty()))
+        frame = frame->GetNextSibling();
+      if (frame)
+        result = frame;
+    } else {
+      // Because the frame tree is singly linked, to find the last frame,
+      // we have to iterate through all the frames
+      // XXX I have a feeling this could be slow for long blocks, although
+      //     I can't find any slowdowns
+      while (frame) {
+        if (!frame->IsEmpty() && SelfIsSelectable(frame, aFlags))
+          result = frame;
+        frame = frame->GetNextSibling();
+      }
+    }
+    if (result)
+      return DrillDownToSelectionFrame(result, aEndFrame, aFlags);
+  }
+  // If the current frame has no targetable children, target the current frame
+  return FrameTarget(aFrame, true, aEndFrame);
+}
+
+// This method finds the closest valid FrameTarget on a given line; if there is
+// no valid FrameTarget on the line, it returns a null FrameTarget
+static FrameTarget GetSelectionClosestFrameForLine(
+                      nsBlockFrame* aParent,
+                      nsBlockFrame::LineIterator aLine,
+                      nsPoint aPoint,
+                      uint32_t aFlags)
+{
+  nsIFrame *frame = aLine->mFirstChild;
+  // Account for end of lines (any iterator from the block is valid)
+  if (aLine == aParent->LinesEnd())
+    return DrillDownToSelectionFrame(aParent, true, aFlags);
+  nsIFrame *closestFromIStart = nullptr, *closestFromIEnd = nullptr;
+  nscoord closestIStart = aLine->IStart(), closestIEnd = aLine->IEnd();
+  WritingMode wm = aLine->mWritingMode;
+  LogicalPoint pt(wm, aPoint, aLine->mContainerSize);
+  bool canSkipBr = false;
+  for (int32_t n = aLine->GetChildCount(); n;
+       --n, frame = frame->GetNextSibling()) {
+    // Skip brFrames. Can only skip if the line contains at least
+    // one selectable and non-empty frame before
+    if (!SelfIsSelectable(frame, aFlags) || frame->IsEmpty() ||
+        (canSkipBr && frame->GetType() == nsGkAtoms::brFrame)) {
+      continue;
+    }
+    canSkipBr = true;
+    LogicalRect frameRect = LogicalRect(wm, frame->GetRect(),
+                                        aLine->mContainerSize);
+    if (pt.I(wm) >= frameRect.IStart(wm)) {
+      if (pt.I(wm) < frameRect.IEnd(wm)) {
+        return GetSelectionClosestFrameForChild(frame, aPoint, aFlags);
+      }
+      if (frameRect.IEnd(wm) >= closestIStart) {
+        closestFromIStart = frame;
+        closestIStart = frameRect.IEnd(wm);
+      }
+    } else {
+      if (frameRect.IStart(wm) <= closestIEnd) {
+        closestFromIEnd = frame;
+        closestIEnd = frameRect.IStart(wm);
+      }
+    }
+  }
+  if (!closestFromIStart && !closestFromIEnd) {
+    // We should only get here if there are no selectable frames on a line
+    // XXX Do we need more elaborate handling here?
+    return FrameTarget::Null();
+  }
+  if (closestFromIStart &&
+      (!closestFromIEnd ||
+       (abs(pt.I(wm) - closestIStart) <= abs(pt.I(wm) - closestIEnd)))) {
+    return GetSelectionClosestFrameForChild(closestFromIStart, aPoint,
+                                            aFlags);
+  }
+  return GetSelectionClosestFrameForChild(closestFromIEnd, aPoint, aFlags);
+}
+
+// This method is for the special handling we do for block frames; they're
+// special because they represent paragraphs and because they are organized
+// into lines, which have bounds that are not stored elsewhere in the
+// frame tree.  Returns a null FrameTarget for frames which are not
+// blocks or blocks with no lines except editable one.
+static FrameTarget GetSelectionClosestFrameForBlock(nsIFrame* aFrame,
+                                                    nsPoint aPoint,
+                                                    uint32_t aFlags)
+{
+  nsBlockFrame* bf = nsLayoutUtils::GetAsBlock(aFrame); // used only for QI
+  if (!bf)
+    return FrameTarget::Null();
+
+  // This code searches for the correct line
+  nsBlockFrame::LineIterator firstLine = bf->LinesBegin();
+  nsBlockFrame::LineIterator end = bf->LinesEnd();
+  if (firstLine == end) {
+    nsIContent *blockContent = aFrame->GetContent();
+    if (blockContent) {
+      // Return with empty flag true.
+      return FrameTarget(aFrame, false, false, true);
+    }
+    return FrameTarget::Null();
+  }
+  nsBlockFrame::LineIterator curLine = firstLine;
+  nsBlockFrame::LineIterator closestLine = end;
+  // Convert aPoint into a LogicalPoint in the writing-mode of this block
+  WritingMode wm = curLine->mWritingMode;
+  LogicalPoint pt(wm, aPoint, curLine->mContainerSize);
+  while (curLine != end) {
+    // Check to see if our point lies within the line's block-direction bounds
+    nscoord BCoord = pt.B(wm) - curLine->BStart();
+    nscoord BSize = curLine->BSize();
+    if (BCoord >= 0 && BCoord < BSize) {
+      closestLine = curLine;
+      break; // We found the line; stop looking
+    }
+    if (BCoord < 0)
+      break;
+    ++curLine;
+  }
+
+  if (closestLine == end) {
+    nsBlockFrame::LineIterator prevLine = curLine.prev();
+    nsBlockFrame::LineIterator nextLine = curLine;
+    // Avoid empty lines
+    while (nextLine != end && nextLine->IsEmpty())
+      ++nextLine;
+    while (prevLine != end && prevLine->IsEmpty())
+      --prevLine;
+
+    // This hidden pref dictates whether a point above or below all lines comes
+    // up with a line or the beginning or end of the frame; 0 on Windows,
+    // 1 on other platforms by default at the writing of this code
+    int32_t dragOutOfFrame =
+      Preferences::GetInt("browser.drag_out_of_frame_style");
+
+    if (prevLine == end) {
+      if (dragOutOfFrame == 1 || nextLine == end)
+        return DrillDownToSelectionFrame(aFrame, false, aFlags);
+      closestLine = nextLine;
+    } else if (nextLine == end) {
+      if (dragOutOfFrame == 1)
+        return DrillDownToSelectionFrame(aFrame, true, aFlags);
+      closestLine = prevLine;
+    } else { // Figure out which line is closer
+      if (pt.B(wm) - prevLine->BEnd() < nextLine->BStart() - pt.B(wm))
+        closestLine = prevLine;
+      else
+        closestLine = nextLine;
+    }
+  }
+
+  do {
+    FrameTarget target = GetSelectionClosestFrameForLine(bf, closestLine,
+                                                         aPoint, aFlags);
+    if (!target.IsNull())
+      return target;
+    ++closestLine;
+  } while (closestLine != end);
+  // Fall back to just targeting the last targetable place
+  return DrillDownToSelectionFrame(aFrame, true, aFlags);
+}
+
+// GetSelectionClosestFrame is the helper function that calculates the closest
+// frame to the given point.
+// It doesn't completely account for offset styles, so needs to be used in
+// restricted environments.
+// Cannot handle overlapping frames correctly, so it should receive the output
+// of GetFrameForPoint
+// Guaranteed to return a valid FrameTarget
+static FrameTarget GetSelectionClosestFrame(nsIFrame* aFrame, nsPoint aPoint,
+                                            uint32_t aFlags)
+{
+  {
+    // Handle blocks; if the frame isn't a block, the method fails
+    FrameTarget target = GetSelectionClosestFrameForBlock(aFrame, aPoint, aFlags);
+    if (!target.IsNull())
+      return target;
+  }
+
+  nsIFrame *kid = aFrame->PrincipalChildList().FirstChild();
+
+  if (kid) {
+    // Go through all the child frames to find the closest one
+    nsIFrame::FrameWithDistance closest = { nullptr, nscoord_MAX, nscoord_MAX };
+    for (; kid; kid = kid->GetNextSibling()) {
+      if (!SelfIsSelectable(kid, aFlags) || kid->IsEmpty())
+        continue;
+
+      kid->FindCloserFrameForSelection(aPoint, &closest);
+    }
+    if (closest.mFrame) {
+      if (closest.mFrame->IsSVGText())
+        return FrameTarget(closest.mFrame, false, false);
+      return GetSelectionClosestFrameForChild(closest.mFrame, aPoint, aFlags);
+    }
+  }
+  return FrameTarget(aFrame, false, false);
+}
+
+nsIFrame::ContentOffsets OffsetsForSingleFrame(nsIFrame* aFrame, nsPoint aPoint)
+{
+  nsIFrame::ContentOffsets offsets;
+  FrameContentRange range = GetRangeForFrame(aFrame);
+  offsets.content = range.content;
+  // If there are continuations (meaning it's not one rectangle), this is the
+  // best this function can do
+  if (aFrame->GetNextContinuation() || aFrame->GetPrevContinuation()) {
+    offsets.offset = range.start;
+    offsets.secondaryOffset = range.end;
+    offsets.associate = CARET_ASSOCIATE_AFTER;
+    return offsets;
+  }
+
+  // Figure out whether the offsets should be over, after, or before the frame
+  nsRect rect(nsPoint(0, 0), aFrame->GetSize());
+
+  bool isBlock = aFrame->GetDisplay() != StyleDisplay::Inline;
+  bool isRtl = (aFrame->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL);
+  if ((isBlock && rect.y < aPoint.y) ||
+      (!isBlock && ((isRtl  && rect.x + rect.width / 2 > aPoint.x) || 
+                    (!isRtl && rect.x + rect.width / 2 < aPoint.x)))) {
+    offsets.offset = range.end;
+    if (rect.Contains(aPoint))
+      offsets.secondaryOffset = range.start;
+    else
+      offsets.secondaryOffset = range.end;
+  } else {
+    offsets.offset = range.start;
+    if (rect.Contains(aPoint))
+      offsets.secondaryOffset = range.end;
+    else
+      offsets.secondaryOffset = range.start;
+  }
+  offsets.associate =
+      offsets.offset == range.start ? CARET_ASSOCIATE_AFTER : CARET_ASSOCIATE_BEFORE;
+  return offsets;
+}
+
+static nsIFrame* AdjustFrameForSelectionStyles(nsIFrame* aFrame) {
+  nsIFrame* adjustedFrame = aFrame;
+  for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent())
+  {
+    // These are the conditions that make all children not able to handle
+    // a cursor.
+    StyleUserSelect userSelect = frame->StyleUIReset()->mUserSelect;
+    if (userSelect == StyleUserSelect::MozText) {
+      // If we see a -moz-text element, we shouldn't look further up the parent
+      // chain!
+      break;
+    }
+    if (userSelect == StyleUserSelect::All ||
+        frame->IsGeneratedContentFrame()) {
+      adjustedFrame = frame;
+    }
+  }
+  return adjustedFrame;
+}
+
+nsIFrame::ContentOffsets nsIFrame::GetContentOffsetsFromPoint(nsPoint aPoint,
+                                                              uint32_t aFlags)
+{
+  nsIFrame *adjustedFrame;
+  if (aFlags & IGNORE_SELECTION_STYLE) {
+    adjustedFrame = this;
+  }
+  else {
+    // This section of code deals with special selection styles.  Note that
+    // -moz-all exists, even though it doesn't need to be explicitly handled.
+    //
+    // The offset is forced not to end up in generated content; content offsets
+    // cannot represent content outside of the document's content tree.
+
+    adjustedFrame = AdjustFrameForSelectionStyles(this);
+
+    // -moz-user-select: all needs special handling, because clicking on it
+    // should lead to the whole frame being selected
+    if (adjustedFrame && adjustedFrame->StyleUIReset()->mUserSelect ==
+        StyleUserSelect::All) {
+      nsPoint adjustedPoint = aPoint + this->GetOffsetTo(adjustedFrame);
+      return OffsetsForSingleFrame(adjustedFrame, adjustedPoint);
+    }
+
+    // For other cases, try to find a closest frame starting from the parent of
+    // the unselectable frame
+    if (adjustedFrame != this)
+      adjustedFrame = adjustedFrame->GetParent();
+  }
+
+  nsPoint adjustedPoint = aPoint + this->GetOffsetTo(adjustedFrame);
+
+  FrameTarget closest =
+    GetSelectionClosestFrame(adjustedFrame, adjustedPoint, aFlags);
+
+  if (closest.emptyBlock) {
+    ContentOffsets offsets;
+    NS_ASSERTION(closest.frame,
+                 "closest.frame must not be null when it's empty");
+    offsets.content = closest.frame->GetContent();
+    offsets.offset = 0;
+    offsets.secondaryOffset = 0;
+    offsets.associate = CARET_ASSOCIATE_AFTER;
+    return offsets;
+  }
+
+  // If the correct offset is at one end of a frame, use offset-based
+  // calculation method
+  if (closest.frameEdge) {
+    ContentOffsets offsets;
+    FrameContentRange range = GetRangeForFrame(closest.frame);
+    offsets.content = range.content;
+    if (closest.afterFrame)
+      offsets.offset = range.end;
+    else
+      offsets.offset = range.start;
+    offsets.secondaryOffset = offsets.offset;
+    offsets.associate = offsets.offset == range.start ?
+        CARET_ASSOCIATE_AFTER : CARET_ASSOCIATE_BEFORE;
+    return offsets;
+  }
+
+  nsPoint pt;
+  if (closest.frame != this) {
+    if (closest.frame->IsSVGText()) {
+      pt = nsLayoutUtils::TransformAncestorPointToFrame(closest.frame,
+                                                        aPoint, this);
+    } else {
+      pt = aPoint - closest.frame->GetOffsetTo(this);
+    }
+  } else {
+    pt = aPoint;
+  }
+  return static_cast<nsFrame*>(closest.frame)->CalcContentOffsetsFromFramePoint(pt);
+
+  // XXX should I add some kind of offset standardization?
+  // consider <b>xxxxx</b><i>zzzzz</i>; should any click between the last
+  // x and first z put the cursor in the same logical position in addition
+  // to the same visual position?
+}
+
+nsIFrame::ContentOffsets nsFrame::CalcContentOffsetsFromFramePoint(nsPoint aPoint)
+{
+  return OffsetsForSingleFrame(this, aPoint);
+}
+
+void
+nsIFrame::AssociateImage(const nsStyleImage& aImage, nsPresContext* aPresContext)
+{
+  if (aImage.GetType() != eStyleImageType_Image) {
+    return;
+  }
+
+  imgRequestProxy* req = aImage.GetImageData();
+  if (!req) {
+    return;
+  }
+
+  mozilla::css::ImageLoader* loader =
+    aPresContext->Document()->StyleImageLoader();
+
+  // If this fails there's not much we can do ...
+  loader->AssociateRequestToFrame(req, this);
+}
+
+nsresult
+nsFrame::GetCursor(const nsPoint& aPoint,
+                   nsIFrame::Cursor& aCursor)
+{
+  FillCursorInformationFromStyle(StyleUserInterface(), aCursor);
+  if (NS_STYLE_CURSOR_AUTO == aCursor.mCursor) {
+    // If this is editable, I-beam cursor is better for most elements.
+    aCursor.mCursor =
+      (mContent && mContent->IsEditable())
+      ? NS_STYLE_CURSOR_TEXT : NS_STYLE_CURSOR_DEFAULT;
+  }
+  if (NS_STYLE_CURSOR_TEXT == aCursor.mCursor &&
+      GetWritingMode().IsVertical()) {
+    // Per CSS UI spec, UA may treat value 'text' as
+    // 'vertical-text' for vertical text.
+    aCursor.mCursor = NS_STYLE_CURSOR_VERTICAL_TEXT;
+  }
+
+  return NS_OK;
+}
+
+// Resize and incremental reflow
+
+/* virtual */ void
+nsFrame::MarkIntrinsicISizesDirty()
+{
+  // This version is meant only for what used to be box-to-block adaptors.
+  // It should not be called by other derived classes.
+  if (::IsXULBoxWrapped(this)) {
+    nsBoxLayoutMetrics *metrics = BoxMetrics();
+
+    SizeNeedsRecalc(metrics->mPrefSize);
+    SizeNeedsRecalc(metrics->mMinSize);
+    SizeNeedsRecalc(metrics->mMaxSize);
+    SizeNeedsRecalc(metrics->mBlockPrefSize);
+    SizeNeedsRecalc(metrics->mBlockMinSize);
+    CoordNeedsRecalc(metrics->mFlex);
+    CoordNeedsRecalc(metrics->mAscent);
+  }
+
+  if (GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT) {
+    nsFontInflationData::MarkFontInflationDataTextDirty(this);
+  }
+}
+
+/* virtual */ nscoord
+nsFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+{
+  nscoord result = 0;
+  DISPLAY_MIN_WIDTH(this, result);
+  return result;
+}
+
+/* virtual */ nscoord
+nsFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+{
+  nscoord result = 0;
+  DISPLAY_PREF_WIDTH(this, result);
+  return result;
+}
+
+/* virtual */ void
+nsFrame::AddInlineMinISize(nsRenderingContext* aRenderingContext,
+                           nsIFrame::InlineMinISizeData* aData)
+{
+  nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
+                    this, nsLayoutUtils::MIN_ISIZE);
+  aData->DefaultAddInlineMinISize(this, isize);
+}
+
+/* virtual */ void
+nsFrame::AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+                            nsIFrame::InlinePrefISizeData* aData)
+{
+  nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
+                    this, nsLayoutUtils::PREF_ISIZE);
+  aData->DefaultAddInlinePrefISize(isize);
+}
+
+void
+nsIFrame::InlineMinISizeData::DefaultAddInlineMinISize(nsIFrame* aFrame,
+                                                       nscoord   aISize,
+                                                       bool      aAllowBreak)
+{
+  auto parent = aFrame->GetParent();
+  MOZ_ASSERT(parent, "Must have a parent if we get here!");
+  const bool mayBreak = aAllowBreak &&
+    !aFrame->CanContinueTextRun() &&
+    !parent->StyleContext()->ShouldSuppressLineBreak() &&
+    parent->StyleText()->WhiteSpaceCanWrap(parent);
+  if (mayBreak) {
+    OptionallyBreak();
+  }
+  mTrailingWhitespace = 0;
+  mSkipWhitespace = false;
+  mCurrentLine += aISize;
+  mAtStartOfLine = false;
+  if (mayBreak) {
+    OptionallyBreak();
+  }
+}
+
+void
+nsIFrame::InlinePrefISizeData::DefaultAddInlinePrefISize(nscoord aISize)
+{
+  mCurrentLine = NSCoordSaturatingAdd(mCurrentLine, aISize);
+  mTrailingWhitespace = 0;
+  mSkipWhitespace = false;
+}
+
+void
+nsIFrame::InlineMinISizeData::ForceBreak()
+{
+  mCurrentLine -= mTrailingWhitespace;
+  mPrevLines = std::max(mPrevLines, mCurrentLine);
+  mCurrentLine = mTrailingWhitespace = 0;
+
+  for (uint32_t i = 0, i_end = mFloats.Length(); i != i_end; ++i) {
+    nscoord float_min = mFloats[i].Width();
+    if (float_min > mPrevLines)
+      mPrevLines = float_min;
+  }
+  mFloats.Clear();
+  mSkipWhitespace = true;
+}
+
+void
+nsIFrame::InlineMinISizeData::OptionallyBreak(nscoord aHyphenWidth)
+{
+  // If we can fit more content into a smaller width by staying on this
+  // line (because we're still at a negative offset due to negative
+  // text-indent or negative margin), don't break.  Otherwise, do the
+  // same as ForceBreak.  it doesn't really matter when we accumulate
+  // floats.
+  if (mCurrentLine + aHyphenWidth < 0 || mAtStartOfLine)
+    return;
+  mCurrentLine += aHyphenWidth;
+  ForceBreak();
+}
+
+void
+nsIFrame::InlinePrefISizeData::ForceBreak()
+{
+  if (mFloats.Length() != 0) {
+            // preferred widths accumulated for floats that have already
+            // been cleared past
+    nscoord floats_done = 0,
+            // preferred widths accumulated for floats that have not yet
+            // been cleared past
+            floats_cur_left = 0,
+            floats_cur_right = 0;
+
+    for (uint32_t i = 0, i_end = mFloats.Length(); i != i_end; ++i) {
+      const FloatInfo& floatInfo = mFloats[i];
+      const nsStyleDisplay* floatDisp = floatInfo.Frame()->StyleDisplay();
+      StyleClear breakType = floatDisp->PhysicalBreakType(mLineContainerWM);
+      if (breakType == StyleClear::Left ||
+          breakType == StyleClear::Right ||
+          breakType == StyleClear::Both) {
+        nscoord floats_cur = NSCoordSaturatingAdd(floats_cur_left,
+                                                  floats_cur_right);
+        if (floats_cur > floats_done) {
+          floats_done = floats_cur;
+        }
+        if (breakType != StyleClear::Right) {
+          floats_cur_left = 0;
+        }
+        if (breakType != StyleClear::Left) {
+          floats_cur_right = 0;
+        }
+      }
+
+      StyleFloat floatStyle = floatDisp->PhysicalFloats(mLineContainerWM);
+      nscoord& floats_cur =
+        floatStyle == StyleFloat::Left ? floats_cur_left : floats_cur_right;
+      nscoord floatWidth = floatInfo.Width();
+      // Negative-width floats don't change the available space so they
+      // shouldn't change our intrinsic line width either.
+      floats_cur =
+        NSCoordSaturatingAdd(floats_cur, std::max(0, floatWidth));
+    }
+
+    nscoord floats_cur =
+      NSCoordSaturatingAdd(floats_cur_left, floats_cur_right);
+    if (floats_cur > floats_done)
+      floats_done = floats_cur;
+
+    mCurrentLine = NSCoordSaturatingAdd(mCurrentLine, floats_done);
+
+    mFloats.Clear();
+  }
+
+  mCurrentLine =
+    NSCoordSaturatingSubtract(mCurrentLine, mTrailingWhitespace, nscoord_MAX);
+  mPrevLines = std::max(mPrevLines, mCurrentLine);
+  mCurrentLine = mTrailingWhitespace = 0;
+  mSkipWhitespace = true;
+}
+
+static void
+AddCoord(const nsStyleCoord& aStyle,
+         nsIFrame* aFrame,
+         nscoord* aCoord, float* aPercent,
+         bool aClampNegativeToZero)
+{
+  switch (aStyle.GetUnit()) {
+    case eStyleUnit_Coord: {
+      NS_ASSERTION(!aClampNegativeToZero || aStyle.GetCoordValue() >= 0,
+                   "unexpected negative value");
+      *aCoord += aStyle.GetCoordValue();
+      return;
+    }
+    case eStyleUnit_Percent: {
+      NS_ASSERTION(!aClampNegativeToZero || aStyle.GetPercentValue() >= 0.0f,
+                   "unexpected negative value");
+      *aPercent += aStyle.GetPercentValue();
+      return;
+    }
+    case eStyleUnit_Calc: {
+      const nsStyleCoord::Calc *calc = aStyle.GetCalcValue();
+      if (aClampNegativeToZero) {
+        // This is far from ideal when one is negative and one is positive.
+        *aCoord += std::max(calc->mLength, 0);
+        *aPercent += std::max(calc->mPercent, 0.0f);
+      } else {
+        *aCoord += calc->mLength;
+        *aPercent += calc->mPercent;
+      }
+      return;
+    }
+    default: {
+      return;
+    }
+  }
+}
+
+static nsIFrame::IntrinsicISizeOffsetData
+IntrinsicSizeOffsets(nsIFrame* aFrame, bool aForISize)
+{
+  nsIFrame::IntrinsicISizeOffsetData result;
+  WritingMode wm = aFrame->GetWritingMode();
+  const nsStyleMargin* styleMargin = aFrame->StyleMargin();
+  bool verticalAxis = aForISize == wm.IsVertical();
+  AddCoord(verticalAxis ? styleMargin->mMargin.GetTop()
+                        : styleMargin->mMargin.GetLeft(),
+           aFrame, &result.hMargin, &result.hPctMargin,
+           false);
+  AddCoord(verticalAxis ? styleMargin->mMargin.GetBottom()
+                        : styleMargin->mMargin.GetRight(),
+           aFrame, &result.hMargin, &result.hPctMargin,
+           false);
+
+  const nsStylePadding* stylePadding = aFrame->StylePadding();
+  AddCoord(verticalAxis ? stylePadding->mPadding.GetTop()
+                        : stylePadding->mPadding.GetLeft(),
+           aFrame, &result.hPadding, &result.hPctPadding,
+           true);
+  AddCoord(verticalAxis ? stylePadding->mPadding.GetBottom()
+                        : stylePadding->mPadding.GetRight(),
+           aFrame, &result.hPadding, &result.hPctPadding,
+           true);
+
+  const nsStyleBorder* styleBorder = aFrame->StyleBorder();
+  if (verticalAxis) {
+    result.hBorder += styleBorder->GetComputedBorderWidth(NS_SIDE_TOP);
+    result.hBorder += styleBorder->GetComputedBorderWidth(NS_SIDE_BOTTOM);
+  } else {
+    result.hBorder += styleBorder->GetComputedBorderWidth(NS_SIDE_LEFT);
+    result.hBorder += styleBorder->GetComputedBorderWidth(NS_SIDE_RIGHT);
+  }
+
+  const nsStyleDisplay* disp = aFrame->StyleDisplay();
+  if (aFrame->IsThemed(disp)) {
+    nsPresContext* presContext = aFrame->PresContext();
+
+    nsIntMargin border;
+    presContext->GetTheme()->GetWidgetBorder(presContext->DeviceContext(),
+                                             aFrame, disp->mAppearance,
+                                             &border);
+    result.hBorder =
+      presContext->DevPixelsToAppUnits(verticalAxis ? border.TopBottom()
+                                                    : border.LeftRight());
+
+    nsIntMargin padding;
+    if (presContext->GetTheme()->GetWidgetPadding(presContext->DeviceContext(),
+                                                  aFrame, disp->mAppearance,
+                                                  &padding)) {
+      result.hPadding =
+        presContext->DevPixelsToAppUnits(verticalAxis ? padding.TopBottom()
+                                                      : padding.LeftRight());
+      result.hPctPadding = 0;
+    }
+  }
+  return result;
+}
+
+/* virtual */ nsIFrame::IntrinsicISizeOffsetData
+nsFrame::IntrinsicISizeOffsets()
+{
+  return IntrinsicSizeOffsets(this, true);
+}
+
+nsIFrame::IntrinsicISizeOffsetData
+nsIFrame::IntrinsicBSizeOffsets()
+{
+  return IntrinsicSizeOffsets(this, false);
+}
+
+/* virtual */ IntrinsicSize
+nsFrame::GetIntrinsicSize()
+{
+  return IntrinsicSize(); // default is width/height set to eStyleUnit_None
+}
+
+/* virtual */ nsSize
+nsFrame::GetIntrinsicRatio()
+{
+  return nsSize(0, 0);
+}
+
+/* virtual */
+LogicalSize
+nsFrame::ComputeSize(nsRenderingContext* aRenderingContext,
+                     WritingMode         aWM,
+                     const LogicalSize&  aCBSize,
+                     nscoord             aAvailableISize,
+                     const LogicalSize&  aMargin,
+                     const LogicalSize&  aBorder,
+                     const LogicalSize&  aPadding,
+                     ComputeSizeFlags    aFlags)
+{
+  MOZ_ASSERT(GetIntrinsicRatio() == nsSize(0,0),
+             "Please override this method and call "
+             "nsFrame::ComputeSizeWithIntrinsicDimensions instead.");
+  LogicalSize result = ComputeAutoSize(aRenderingContext, aWM,
+                                       aCBSize, aAvailableISize,
+                                       aMargin, aBorder, aPadding,
+                                       aFlags);
+  const nsStylePosition *stylePos = StylePosition();
+
+  LogicalSize boxSizingAdjust(aWM);
+  if (stylePos->mBoxSizing == StyleBoxSizing::Border) {
+    boxSizingAdjust = aBorder + aPadding;
+  }
+  nscoord boxSizingToMarginEdgeISize =
+    aMargin.ISize(aWM) + aBorder.ISize(aWM) + aPadding.ISize(aWM) -
+    boxSizingAdjust.ISize(aWM);
+
+  const nsStyleCoord* inlineStyleCoord = &stylePos->ISize(aWM);
+  const nsStyleCoord* blockStyleCoord = &stylePos->BSize(aWM);
+
+  nsIAtom* parentFrameType = GetParent() ? GetParent()->GetType() : nullptr;
+  auto alignCB = GetParent();
+  bool isGridItem = (parentFrameType == nsGkAtoms::gridContainerFrame &&
+                     !(GetStateBits() & NS_FRAME_OUT_OF_FLOW));
+  if (parentFrameType == nsGkAtoms::tableWrapperFrame &&
+      GetType() == nsGkAtoms::tableFrame) {
+    // An inner table frame is sized as a grid item if its table wrapper is,
+    // because they actually have the same CB (the wrapper's CB).
+    // @see ReflowInput::InitCBReflowInput
+    auto tableWrapper = GetParent();
+    auto grandParent = tableWrapper->GetParent();
+    isGridItem = (grandParent->GetType() == nsGkAtoms::gridContainerFrame &&
+                  !(tableWrapper->GetStateBits() & NS_FRAME_OUT_OF_FLOW));
+    if (isGridItem) {
+      // When resolving justify/align-self below, we want to use the grid
+      // container's justify/align-items value and WritingMode.
+      alignCB = grandParent;
+    }
+  }
+  bool isFlexItem = (parentFrameType == nsGkAtoms::flexContainerFrame &&
+                     !(GetStateBits() & NS_FRAME_OUT_OF_FLOW));
+  bool isInlineFlexItem = false;
+  if (isFlexItem) {
+    // Flex items use their "flex-basis" property in place of their main-size
+    // property (e.g. "width") for sizing purposes, *unless* they have
+    // "flex-basis:auto", in which case they use their main-size property after
+    // all.
+    uint32_t flexDirection = GetParent()->StylePosition()->mFlexDirection;
+    isInlineFlexItem =
+      flexDirection == NS_STYLE_FLEX_DIRECTION_ROW ||
+      flexDirection == NS_STYLE_FLEX_DIRECTION_ROW_REVERSE;
+
+    // NOTE: The logic here should match the similar chunk for determining
+    // inlineStyleCoord and blockStyleCoord in
+    // nsFrame::ComputeSizeWithIntrinsicDimensions().
+    const nsStyleCoord* flexBasis = &(stylePos->mFlexBasis);
+    if (flexBasis->GetUnit() != eStyleUnit_Auto) {
+      if (isInlineFlexItem) {
+        inlineStyleCoord = flexBasis;
+      } else {
+        // One caveat for vertical flex items: We don't support enumerated
+        // values (e.g. "max-content") for height properties yet. So, if our
+        // computed flex-basis is an enumerated value, we'll just behave as if
+        // it were "auto", which means "use the main-size property after all"
+        // (which is "height", in this case).
+        // NOTE: Once we support intrinsic sizing keywords for "height",
+        // we should remove this check.
+        if (flexBasis->GetUnit() != eStyleUnit_Enumerated) {
+          blockStyleCoord = flexBasis;
+        }
+      }
+    }
+  }
+
+  // Compute inline-axis size
+
+  if (inlineStyleCoord->GetUnit() != eStyleUnit_Auto) {
+    result.ISize(aWM) =
+      ComputeISizeValue(aRenderingContext, aCBSize.ISize(aWM),
+                        boxSizingAdjust.ISize(aWM), boxSizingToMarginEdgeISize,
+                        *inlineStyleCoord, aFlags);
+  } else if (MOZ_UNLIKELY(isGridItem) &&
+             !IS_TRUE_OVERFLOW_CONTAINER(this)) {
+    // 'auto' inline-size for grid-level box - fill the CB for 'stretch' /
+    // 'normal' and clamp it to the CB if requested:
+    bool stretch = false;
+    if (!(aFlags & nsIFrame::eShrinkWrap) &&
+        !StyleMargin()->HasInlineAxisAuto(aWM)) {
+      auto inlineAxisAlignment =
+        aWM.IsOrthogonalTo(alignCB->GetWritingMode()) ?
+          StylePosition()->UsedAlignSelf(alignCB->StyleContext()) :
+          StylePosition()->UsedJustifySelf(alignCB->StyleContext());
+      stretch = inlineAxisAlignment == NS_STYLE_ALIGN_NORMAL ||
+                inlineAxisAlignment == NS_STYLE_ALIGN_STRETCH;
+    }
+    if (stretch || (aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize)) {
+      auto iSizeToFillCB = std::max(nscoord(0), aCBSize.ISize(aWM) -
+                                                aPadding.ISize(aWM) -
+                                                aBorder.ISize(aWM) -
+                                                aMargin.ISize(aWM));
+      if (stretch || result.ISize(aWM) > iSizeToFillCB) {
+        result.ISize(aWM) = iSizeToFillCB;
+      }
+    }
+  }
+
+  // Flex items ignore their min & max sizing properties in their
+  // flex container's main-axis.  (Those properties get applied later in
+  // the flexbox algorithm.)
+  const nsStyleCoord& maxISizeCoord = stylePos->MaxISize(aWM);
+  nscoord maxISize = NS_UNCONSTRAINEDSIZE;
+  if (maxISizeCoord.GetUnit() != eStyleUnit_None &&
+      !(isFlexItem && isInlineFlexItem)) {
+    maxISize =
+      ComputeISizeValue(aRenderingContext, aCBSize.ISize(aWM),
+                        boxSizingAdjust.ISize(aWM), boxSizingToMarginEdgeISize,
+                        maxISizeCoord, aFlags);
+    result.ISize(aWM) = std::min(maxISize, result.ISize(aWM));
+  }
+
+  const nsStyleCoord& minISizeCoord = stylePos->MinISize(aWM);
+  nscoord minISize;
+  if (minISizeCoord.GetUnit() != eStyleUnit_Auto &&
+      !(isFlexItem && isInlineFlexItem)) {
+    minISize =
+      ComputeISizeValue(aRenderingContext, aCBSize.ISize(aWM),
+                        boxSizingAdjust.ISize(aWM), boxSizingToMarginEdgeISize,
+                        minISizeCoord, aFlags);
+  } else if (MOZ_UNLIKELY(isGridItem)) {
+    // This implements "Implied Minimum Size of Grid Items".
+    // https://drafts.csswg.org/css-grid/#min-size-auto
+    minISize = std::min(maxISize, GetMinISize(aRenderingContext));
+    if (inlineStyleCoord->IsCoordPercentCalcUnit()) {
+      minISize = std::min(minISize, result.ISize(aWM));
+    } else if (aFlags & eIClampMarginBoxMinSize) {
+      // "if the grid item spans only grid tracks that have a fixed max track
+      // sizing function, its automatic minimum size in that dimension is
+      // further clamped to less than or equal to the size necessary to fit
+      // its margin box within the resulting grid area (flooring at zero)"
+      // https://drafts.csswg.org/css-grid/#min-size-auto
+      auto maxMinISize = std::max(nscoord(0), aCBSize.ISize(aWM) -
+                                              aPadding.ISize(aWM) -
+                                              aBorder.ISize(aWM) -
+                                              aMargin.ISize(aWM));
+      minISize = std::min(minISize, maxMinISize);
+    }
+  } else {
+    // Treat "min-width: auto" as 0.
+    // NOTE: Technically, "auto" is supposed to behave like "min-content" on
+    // flex items. However, we don't need to worry about that here, because
+    // flex items' min-sizes are intentionally ignored until the flex
+    // container explicitly considers them during space distribution.
+    minISize = 0;
+  }
+  result.ISize(aWM) = std::max(minISize, result.ISize(aWM));
+
+  // Compute block-axis size
+  // (but not if we have auto bsize or if we recieved the "eUseAutoBSize"
+  // flag -- then, we'll just stick with the bsize that we already calculated
+  // in the initial ComputeAutoSize() call.)
+  if (!(aFlags & nsIFrame::eUseAutoBSize)) {
+    if (!nsLayoutUtils::IsAutoBSize(*blockStyleCoord, aCBSize.BSize(aWM))) {
+      result.BSize(aWM) =
+        nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM),
+                                         boxSizingAdjust.BSize(aWM),
+                                         *blockStyleCoord);
+    } else if (MOZ_UNLIKELY(isGridItem) &&
+               blockStyleCoord->GetUnit() == eStyleUnit_Auto &&
+               !IS_TRUE_OVERFLOW_CONTAINER(this)) {
+      auto cbSize = aCBSize.BSize(aWM);
+      if (cbSize != NS_AUTOHEIGHT) {
+        // 'auto' block-size for grid-level box - fill the CB for 'stretch' /
+        // 'normal' and clamp it to the CB if requested:
+        bool stretch = false;
+        if (!StyleMargin()->HasBlockAxisAuto(aWM)) {
+          auto blockAxisAlignment =
+            !aWM.IsOrthogonalTo(alignCB->GetWritingMode()) ?
+              StylePosition()->UsedAlignSelf(alignCB->StyleContext()) :
+              StylePosition()->UsedJustifySelf(alignCB->StyleContext());
+          stretch = blockAxisAlignment == NS_STYLE_ALIGN_NORMAL ||
+                    blockAxisAlignment == NS_STYLE_ALIGN_STRETCH;
+        }
+        if (stretch || (aFlags & ComputeSizeFlags::eBClampMarginBoxMinSize)) {
+          auto bSizeToFillCB = std::max(nscoord(0), cbSize -
+                                                    aPadding.BSize(aWM) -
+                                                    aBorder.BSize(aWM) -
+                                                    aMargin.BSize(aWM));
+          if (stretch || (result.BSize(aWM) != NS_AUTOHEIGHT &&
+                          result.BSize(aWM) > bSizeToFillCB)) {
+            result.BSize(aWM) = bSizeToFillCB;
+          }
+        }
+      }
+    }
+  }
+
+  const nsStyleCoord& maxBSizeCoord = stylePos->MaxBSize(aWM);
+
+  if (result.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
+    if (!nsLayoutUtils::IsAutoBSize(maxBSizeCoord, aCBSize.BSize(aWM)) &&
+        !(isFlexItem && !isInlineFlexItem)) {
+      nscoord maxBSize =
+        nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM),
+                                         boxSizingAdjust.BSize(aWM),
+                                         maxBSizeCoord);
+      result.BSize(aWM) = std::min(maxBSize, result.BSize(aWM));
+    }
+
+    const nsStyleCoord& minBSizeCoord = stylePos->MinBSize(aWM);
+
+    if (!nsLayoutUtils::IsAutoBSize(minBSizeCoord, aCBSize.BSize(aWM)) &&
+        !(isFlexItem && !isInlineFlexItem)) {
+      nscoord minBSize =
+        nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM),
+                                         boxSizingAdjust.BSize(aWM),
+                                         minBSizeCoord);
+      result.BSize(aWM) = std::max(minBSize, result.BSize(aWM));
+    }
+  }
+
+  const nsStyleDisplay *disp = StyleDisplay();
+  if (IsThemed(disp)) {
+    LayoutDeviceIntSize widget;
+    bool canOverride = true;
+    nsPresContext *presContext = PresContext();
+    presContext->GetTheme()->
+      GetMinimumWidgetSize(presContext, this, disp->mAppearance,
+                           &widget, &canOverride);
+
+    // Convert themed widget's physical dimensions to logical coords
+    LogicalSize size(aWM,
+                     nsSize(presContext->DevPixelsToAppUnits(widget.width),
+                            presContext->DevPixelsToAppUnits(widget.height)));
+
+    // GMWS() returns border-box; we need content-box
+    size.ISize(aWM) -= aBorder.ISize(aWM) + aPadding.ISize(aWM);
+    size.BSize(aWM) -= aBorder.BSize(aWM) + aPadding.BSize(aWM);
+
+    if (size.BSize(aWM) > result.BSize(aWM) || !canOverride) {
+      result.BSize(aWM) = size.BSize(aWM);
+    }
+    if (size.ISize(aWM) > result.ISize(aWM) || !canOverride) {
+      result.ISize(aWM) = size.ISize(aWM);
+    }
+  }
+
+  result.ISize(aWM) = std::max(0, result.ISize(aWM));
+  result.BSize(aWM) = std::max(0, result.BSize(aWM));
+
+  return result;
+}
+
+LogicalSize
+nsFrame::ComputeSizeWithIntrinsicDimensions(nsRenderingContext*  aRenderingContext,
+                                            WritingMode          aWM,
+                                            const IntrinsicSize& aIntrinsicSize,
+                                            nsSize               aIntrinsicRatio,
+                                            const LogicalSize&   aCBSize,
+                                            const LogicalSize&   aMargin,
+                                            const LogicalSize&   aBorder,
+                                            const LogicalSize&   aPadding,
+                                            ComputeSizeFlags     aFlags)
+{
+  const nsStylePosition* stylePos = StylePosition();
+  const nsStyleCoord* inlineStyleCoord = &stylePos->ISize(aWM);
+  const nsStyleCoord* blockStyleCoord = &stylePos->BSize(aWM);
+  const nsIAtom* parentFrameType =
+    GetParent() ? GetParent()->GetType() : nullptr;
+  const bool isGridItem = (parentFrameType == nsGkAtoms::gridContainerFrame &&
+                           !(GetStateBits() & NS_FRAME_OUT_OF_FLOW));
+  const bool isFlexItem = (parentFrameType == nsGkAtoms::flexContainerFrame &&
+                           !(GetStateBits() & NS_FRAME_OUT_OF_FLOW));
+  bool isInlineFlexItem = false;
+  Maybe<nsStyleCoord> imposedMainSizeStyleCoord;
+
+  // If this is a flex item, and we're measuring its cross size after flexing
+  // to resolve its main size, then we need to use the resolved main size
+  // that the container provides to us *instead of* the main-size coordinate
+  // from our style struct. (Otherwise, we'll be using an irrelevant value in
+  // the aspect-ratio calculations below.)
+  if (isFlexItem) {
+    uint32_t flexDirection =
+      GetParent()->StylePosition()->mFlexDirection;
+    isInlineFlexItem =
+      flexDirection == NS_STYLE_FLEX_DIRECTION_ROW ||
+      flexDirection == NS_STYLE_FLEX_DIRECTION_ROW_REVERSE;
+
+    // If FlexItemMainSizeOverride frame-property is set, then that means the
+    // flex container is imposing a main-size on this flex item for it to use
+    // as its size in the container's main axis.
+    FrameProperties props = Properties();
+    bool didImposeMainSize;
+    nscoord imposedMainSize =
+      props.Get(nsIFrame::FlexItemMainSizeOverride(), &didImposeMainSize);
+    if (didImposeMainSize) {
+      imposedMainSizeStyleCoord.emplace(imposedMainSize,
+                                        nsStyleCoord::CoordConstructor);
+      if (isInlineFlexItem) {
+        inlineStyleCoord = imposedMainSizeStyleCoord.ptr();
+      } else {
+        blockStyleCoord = imposedMainSizeStyleCoord.ptr();
+      }
+
+    } else {
+      // Flex items use their "flex-basis" property in place of their main-size
+      // property (e.g. "width") for sizing purposes, *unless* they have
+      // "flex-basis:auto", in which case they use their main-size property
+      // after all.
+      // NOTE: The logic here should match the similar chunk for determining
+      // inlineStyleCoord and blockStyleCoord in nsFrame::ComputeSize().
+      const nsStyleCoord* flexBasis = &(stylePos->mFlexBasis);
+      if (flexBasis->GetUnit() != eStyleUnit_Auto) {
+        if (isInlineFlexItem) {
+          inlineStyleCoord = flexBasis;
+        } else {
+          // One caveat for vertical flex items: We don't support enumerated
+          // values (e.g. "max-content") for height properties yet. So, if our
+          // computed flex-basis is an enumerated value, we'll just behave as if
+          // it were "auto", which means "use the main-size property after all"
+          // (which is "height", in this case).
+          // NOTE: Once we support intrinsic sizing keywords for "height",
+          // we should remove this check.
+          if (flexBasis->GetUnit() != eStyleUnit_Enumerated) {
+            blockStyleCoord = flexBasis;
+          }
+        }
+      }
+    }
+  }
+
+  // Handle intrinsic sizes and their interaction with
+  // {min-,max-,}{width,height} according to the rules in
+  // http://www.w3.org/TR/CSS21/visudet.html#min-max-widths
+
+  // Note: throughout the following section of the function, I avoid
+  // a * (b / c) because of its reduced accuracy relative to a * b / c
+  // or (a * b) / c (which are equivalent).
+
+  const bool isAutoISize = inlineStyleCoord->GetUnit() == eStyleUnit_Auto;
+  const bool isAutoBSize =
+    nsLayoutUtils::IsAutoBSize(*blockStyleCoord, aCBSize.BSize(aWM));
+
+  LogicalSize boxSizingAdjust(aWM);
+  if (stylePos->mBoxSizing == StyleBoxSizing::Border) {
+    boxSizingAdjust = aBorder + aPadding;
+  }
+  nscoord boxSizingToMarginEdgeISize =
+    aMargin.ISize(aWM) + aBorder.ISize(aWM) + aPadding.ISize(aWM) -
+      boxSizingAdjust.ISize(aWM);
+
+  nscoord iSize, minISize, maxISize, bSize, minBSize, maxBSize;
+  enum class Stretch {
+    // stretch to fill the CB (preserving intrinsic ratio) in the relevant axis
+    eStretchPreservingRatio,
+    // stretch to fill the CB in the relevant axis
+    eStretch,
+    // no stretching in the relevant axis
+    eNoStretch,
+  };
+  // just to avoid having to type these out everywhere:
+  const auto eStretchPreservingRatio = Stretch::eStretchPreservingRatio;
+  const auto eStretch = Stretch::eStretch;
+  const auto eNoStretch = Stretch::eNoStretch;
+
+  Stretch stretchI = eNoStretch; // stretch behavior in the inline axis
+  Stretch stretchB = eNoStretch; // stretch behavior in the block axis
+
+  if (!isAutoISize) {
+    iSize = ComputeISizeValue(aRenderingContext,
+              aCBSize.ISize(aWM), boxSizingAdjust.ISize(aWM),
+              boxSizingToMarginEdgeISize, *inlineStyleCoord, aFlags);
+  } else if (MOZ_UNLIKELY(isGridItem)) {
+    MOZ_ASSERT(!IS_TRUE_OVERFLOW_CONTAINER(this));
+    // 'auto' inline-size for grid-level box - apply 'stretch' as needed:
+    auto cbSize = aCBSize.ISize(aWM);
+    if (cbSize != NS_UNCONSTRAINEDSIZE) {
+      if (!StyleMargin()->HasInlineAxisAuto(aWM)) {
+        auto inlineAxisAlignment =
+          aWM.IsOrthogonalTo(GetParent()->GetWritingMode()) ?
+            stylePos->UsedAlignSelf(GetParent()->StyleContext()) :
+            stylePos->UsedJustifySelf(GetParent()->StyleContext());
+        if (inlineAxisAlignment == NS_STYLE_ALIGN_NORMAL) {
+          stretchI = eStretchPreservingRatio;
+        } else if (inlineAxisAlignment == NS_STYLE_ALIGN_STRETCH) {
+          stretchI = eStretch;
+        }
+      }
+      if (stretchI != eNoStretch ||
+          (aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize)) {
+        iSize = std::max(nscoord(0), cbSize -
+                                     aPadding.ISize(aWM) -
+                                     aBorder.ISize(aWM) -
+                                     aMargin.ISize(aWM));
+      }
+    } else {
+      // Reset this flag to avoid applying the clamping below.
+      aFlags = ComputeSizeFlags(aFlags &
+                                ~ComputeSizeFlags::eIClampMarginBoxMinSize);
+    }
+  }
+
+  const nsStyleCoord& maxISizeCoord = stylePos->MaxISize(aWM);
+
+  if (maxISizeCoord.GetUnit() != eStyleUnit_None &&
+      !(isFlexItem && isInlineFlexItem)) {
+    maxISize = ComputeISizeValue(aRenderingContext,
+                 aCBSize.ISize(aWM), boxSizingAdjust.ISize(aWM),
+                 boxSizingToMarginEdgeISize, maxISizeCoord, aFlags);
+  } else {
+    maxISize = nscoord_MAX;
+  }
+
+  // NOTE: Flex items ignore their min & max sizing properties in their
+  // flex container's main-axis.  (Those properties get applied later in
+  // the flexbox algorithm.)
+
+  const nsStyleCoord& minISizeCoord = stylePos->MinISize(aWM);
+
+  if (minISizeCoord.GetUnit() != eStyleUnit_Auto &&
+      !(isFlexItem && isInlineFlexItem)) {
+    minISize = ComputeISizeValue(aRenderingContext,
+                 aCBSize.ISize(aWM), boxSizingAdjust.ISize(aWM),
+                 boxSizingToMarginEdgeISize, minISizeCoord, aFlags);
+  } else {
+    // Treat "min-width: auto" as 0.
+    // NOTE: Technically, "auto" is supposed to behave like "min-content" on
+    // flex items. However, we don't need to worry about that here, because
+    // flex items' min-sizes are intentionally ignored until the flex
+    // container explicitly considers them during space distribution.
+    minISize = 0;
+  }
+
+  if (!isAutoBSize) {
+    bSize = nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM),
+                boxSizingAdjust.BSize(aWM),
+                *blockStyleCoord);
+  } else if (MOZ_UNLIKELY(isGridItem)) {
+    MOZ_ASSERT(!IS_TRUE_OVERFLOW_CONTAINER(this));
+    // 'auto' block-size for grid-level box - apply 'stretch' as needed:
+    auto cbSize = aCBSize.BSize(aWM);
+    if (cbSize != NS_AUTOHEIGHT) {
+      if (!StyleMargin()->HasBlockAxisAuto(aWM)) {
+        auto blockAxisAlignment =
+          !aWM.IsOrthogonalTo(GetParent()->GetWritingMode()) ?
+            stylePos->UsedAlignSelf(GetParent()->StyleContext()) :
+            stylePos->UsedJustifySelf(GetParent()->StyleContext());
+        if (blockAxisAlignment == NS_STYLE_ALIGN_NORMAL) {
+          stretchB = eStretchPreservingRatio;
+        } else if (blockAxisAlignment == NS_STYLE_ALIGN_STRETCH) {
+          stretchB = eStretch;
+        }
+      }
+      if (stretchB != eNoStretch ||
+          (aFlags & ComputeSizeFlags::eBClampMarginBoxMinSize)) {
+        bSize = std::max(nscoord(0), cbSize -
+                                     aPadding.BSize(aWM) -
+                                     aBorder.BSize(aWM) -
+                                     aMargin.BSize(aWM));
+      }
+    } else {
+      // Reset this flag to avoid applying the clamping below.
+      aFlags = ComputeSizeFlags(aFlags &
+                                ~ComputeSizeFlags::eBClampMarginBoxMinSize);
+    }
+  }
+
+  const nsStyleCoord& maxBSizeCoord = stylePos->MaxBSize(aWM);
+
+  if (!nsLayoutUtils::IsAutoBSize(maxBSizeCoord, aCBSize.BSize(aWM)) &&
+      !(isFlexItem && !isInlineFlexItem)) {
+    maxBSize = nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM),
+                  boxSizingAdjust.BSize(aWM), maxBSizeCoord);
+  } else {
+    maxBSize = nscoord_MAX;
+  }
+
+  const nsStyleCoord& minBSizeCoord = stylePos->MinBSize(aWM);
+
+  if (!nsLayoutUtils::IsAutoBSize(minBSizeCoord, aCBSize.BSize(aWM)) &&
+      !(isFlexItem && !isInlineFlexItem)) {
+    minBSize = nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM),
+                  boxSizingAdjust.BSize(aWM), minBSizeCoord);
+  } else {
+    minBSize = 0;
+  }
+
+  // Resolve percentage intrinsic iSize/bSize as necessary:
+
+  NS_ASSERTION(aCBSize.ISize(aWM) != NS_UNCONSTRAINEDSIZE,
+               "Our containing block must not have unconstrained inline-size!");
+
+  const bool isVertical = aWM.IsVertical();
+  const nsStyleCoord& isizeCoord =
+    isVertical ? aIntrinsicSize.height : aIntrinsicSize.width;
+  const nsStyleCoord& bsizeCoord =
+    isVertical ? aIntrinsicSize.width : aIntrinsicSize.height;
+
+  bool hasIntrinsicISize, hasIntrinsicBSize;
+  nscoord intrinsicISize, intrinsicBSize;
+
+  if (isizeCoord.GetUnit() == eStyleUnit_Coord) {
+    hasIntrinsicISize = true;
+    intrinsicISize = isizeCoord.GetCoordValue();
+    if (intrinsicISize < 0)
+      intrinsicISize = 0;
+  } else {
+    NS_ASSERTION(isizeCoord.GetUnit() == eStyleUnit_None,
+                 "unexpected unit");
+    hasIntrinsicISize = false;
+    intrinsicISize = 0;
+  }
+
+  if (bsizeCoord.GetUnit() == eStyleUnit_Coord) {
+    hasIntrinsicBSize = true;
+    intrinsicBSize = bsizeCoord.GetCoordValue();
+    if (intrinsicBSize < 0)
+      intrinsicBSize = 0;
+  } else {
+    NS_ASSERTION(bsizeCoord.GetUnit() == eStyleUnit_None,
+                 "unexpected unit");
+    hasIntrinsicBSize = false;
+    intrinsicBSize = 0;
+  }
+
+  NS_ASSERTION(aIntrinsicRatio.width >= 0 && aIntrinsicRatio.height >= 0,
+               "Intrinsic ratio has a negative component!");
+  LogicalSize logicalRatio(aWM, aIntrinsicRatio);
+
+  // Now calculate the used values for iSize and bSize:
+
+  if (isAutoISize) {
+    if (isAutoBSize) {
+
+      // 'auto' iSize, 'auto' bSize
+
+      // Get tentative values - CSS 2.1 sections 10.3.2 and 10.6.2:
+
+      nscoord tentISize, tentBSize;
+
+      if (hasIntrinsicISize) {
+        tentISize = intrinsicISize;
+      } else if (hasIntrinsicBSize && logicalRatio.BSize(aWM) > 0) {
+        tentISize = NSCoordMulDiv(intrinsicBSize, logicalRatio.ISize(aWM), logicalRatio.BSize(aWM));
+      } else if (logicalRatio.ISize(aWM) > 0) {
+        tentISize = aCBSize.ISize(aWM) - boxSizingToMarginEdgeISize; // XXX scrollbar?
+        if (tentISize < 0) tentISize = 0;
+      } else {
+        tentISize = nsPresContext::CSSPixelsToAppUnits(300);
+      }
+
+      // If we need to clamp the inline size to fit the CB, we use the 'stretch'
+      // or 'normal' codepath.  We use the ratio-preserving 'normal' codepath
+      // unless we have 'stretch' in the other axis.
+      if ((aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize) &&
+          stretchI != eStretch && tentISize > iSize) {
+        stretchI = (stretchB == eStretch ? eStretch : eStretchPreservingRatio);
+      }
+
+      if (hasIntrinsicBSize) {
+        tentBSize = intrinsicBSize;
+      } else if (logicalRatio.ISize(aWM) > 0) {
+        tentBSize = NSCoordMulDiv(tentISize, logicalRatio.BSize(aWM), logicalRatio.ISize(aWM));
+      } else {
+        tentBSize = nsPresContext::CSSPixelsToAppUnits(150);
+      }
+
+      // (ditto the comment about clamping the inline size above)
+      if ((aFlags & ComputeSizeFlags::eBClampMarginBoxMinSize) &&
+          stretchB != eStretch && tentBSize > bSize) {
+        stretchB = (stretchI == eStretch ? eStretch : eStretchPreservingRatio);
+      }
+
+      if (aIntrinsicRatio != nsSize(0, 0)) {
+        if (stretchI == eStretch) {
+          tentISize = iSize;  // * / 'stretch'
+          if (stretchB == eStretch) {
+            tentBSize = bSize;  // 'stretch' / 'stretch'
+          } else if (stretchB == eStretchPreservingRatio && logicalRatio.ISize(aWM) > 0) {
+            // 'normal' / 'stretch'
+            tentBSize = NSCoordMulDiv(iSize, logicalRatio.BSize(aWM), logicalRatio.ISize(aWM));
+          }
+        } else if (stretchB == eStretch) {
+          tentBSize = bSize;  // 'stretch' / * (except 'stretch')
+          if (stretchI == eStretchPreservingRatio && logicalRatio.BSize(aWM) > 0) {
+            // 'stretch' / 'normal'
+            tentISize = NSCoordMulDiv(bSize, logicalRatio.ISize(aWM), logicalRatio.BSize(aWM));
+          }
+        } else if (stretchI == eStretchPreservingRatio) {
+          tentISize = iSize;  // * (except 'stretch') / 'normal'
+          if (logicalRatio.ISize(aWM) > 0) {
+            tentBSize = NSCoordMulDiv(iSize, logicalRatio.BSize(aWM), logicalRatio.ISize(aWM));
+          }
+          if (stretchB == eStretchPreservingRatio && tentBSize > bSize) {
+            // Stretch within the CB size with preserved intrinsic ratio.
+            tentBSize = bSize;  // 'normal' / 'normal'
+            if (logicalRatio.BSize(aWM) > 0) {
+              tentISize = NSCoordMulDiv(bSize, logicalRatio.ISize(aWM), logicalRatio.BSize(aWM));
+            }
+          }
+        } else if (stretchB == eStretchPreservingRatio) {
+          tentBSize = bSize;  // 'normal' / * (except 'normal' and 'stretch')
+          if (logicalRatio.BSize(aWM) > 0) {
+            tentISize = NSCoordMulDiv(bSize, logicalRatio.ISize(aWM), logicalRatio.BSize(aWM));
+          }
+        }
+      }
+
+      // ComputeAutoSizeWithIntrinsicDimensions preserves the ratio when applying
+      // the min/max-size.  We don't want that when we have 'stretch' in either
+      // axis because tentISize/tentBSize is likely not according to ratio now.
+      if (aIntrinsicRatio != nsSize(0, 0) &&
+          stretchI != eStretch && stretchB != eStretch) {
+        nsSize autoSize = nsLayoutUtils::
+          ComputeAutoSizeWithIntrinsicDimensions(minISize, minBSize,
+                                                 maxISize, maxBSize,
+                                                 tentISize, tentBSize);
+        // The nsSize that ComputeAutoSizeWithIntrinsicDimensions returns will
+        // actually contain logical values if the parameters passed to it were
+        // logical coordinates, so we do NOT perform a physical-to-logical
+        // conversion here, but just assign the fields directly to our result.
+        iSize = autoSize.width;
+        bSize = autoSize.height;
+      } else {
+        // Not honoring an intrinsic ratio: clamp the dimensions independently.
+        iSize = NS_CSS_MINMAX(tentISize, minISize, maxISize);
+        bSize = NS_CSS_MINMAX(tentBSize, minBSize, maxBSize);
+      }
+    } else {
+
+      // 'auto' iSize, non-'auto' bSize
+      bSize = NS_CSS_MINMAX(bSize, minBSize, maxBSize);
+      if (stretchI != eStretch) {
+        if (logicalRatio.BSize(aWM) > 0) {
+          iSize = NSCoordMulDiv(bSize, logicalRatio.ISize(aWM), logicalRatio.BSize(aWM));
+        } else if (hasIntrinsicISize) {
+          if (!((aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize) &&
+                intrinsicISize > iSize)) {
+            iSize = intrinsicISize;
+          } // else - leave iSize as is to fill the CB
+        } else {
+          iSize = nsPresContext::CSSPixelsToAppUnits(300);
+        }
+      } // else - leave iSize as is to fill the CB
+      iSize = NS_CSS_MINMAX(iSize, minISize, maxISize);
+
+    }
+  } else {
+    if (isAutoBSize) {
+
+      // non-'auto' iSize, 'auto' bSize
+      iSize = NS_CSS_MINMAX(iSize, minISize, maxISize);
+      if (stretchB != eStretch) {
+        if (logicalRatio.ISize(aWM) > 0) {
+          bSize = NSCoordMulDiv(iSize, logicalRatio.BSize(aWM), logicalRatio.ISize(aWM));
+        } else if (hasIntrinsicBSize) {
+          if (!((aFlags & ComputeSizeFlags::eBClampMarginBoxMinSize) &&
+                intrinsicBSize > bSize)) {
+            bSize = intrinsicBSize;
+          } // else - leave bSize as is to fill the CB
+        } else {
+          bSize = nsPresContext::CSSPixelsToAppUnits(150);
+        }
+      } // else - leave bSize as is to fill the CB
+      bSize = NS_CSS_MINMAX(bSize, minBSize, maxBSize);
+
+    } else {
+
+      // non-'auto' iSize, non-'auto' bSize
+      iSize = NS_CSS_MINMAX(iSize, minISize, maxISize);
+      bSize = NS_CSS_MINMAX(bSize, minBSize, maxBSize);
+
+    }
+  }
+
+  return LogicalSize(aWM, iSize, bSize);
+}
+
+nsRect
+nsIFrame::ComputeTightBounds(DrawTarget* aDrawTarget) const
+{
+  return GetVisualOverflowRect();
+}
+
+nsRect
+nsFrame::ComputeSimpleTightBounds(DrawTarget* aDrawTarget) const
+{
+  if (StyleOutline()->mOutlineStyle != NS_STYLE_BORDER_STYLE_NONE ||
+      StyleBorder()->HasBorder() || !StyleBackground()->IsTransparent() ||
+      StyleDisplay()->mAppearance) {
+    // Not necessarily tight, due to clipping, negative
+    // outline-offset, and lots of other issues, but that's OK
+    return GetVisualOverflowRect();
+  }
+
+  nsRect r(0, 0, 0, 0);
+  ChildListIterator lists(this);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      nsIFrame* child = childFrames.get();
+      r.UnionRect(r, child->ComputeTightBounds(aDrawTarget) + child->GetPosition());
+    }
+  }
+  return r;
+}
+
+/* virtual */ nsresult
+nsIFrame::GetPrefWidthTightBounds(nsRenderingContext* aContext,
+                                  nscoord* aX,
+                                  nscoord* aXMost)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* virtual */
+LogicalSize
+nsFrame::ComputeAutoSize(nsRenderingContext*         aRenderingContext,
+                         WritingMode                 aWM,
+                         const mozilla::LogicalSize& aCBSize,
+                         nscoord                     aAvailableISize,
+                         const mozilla::LogicalSize& aMargin,
+                         const mozilla::LogicalSize& aBorder,
+                         const mozilla::LogicalSize& aPadding,
+                         ComputeSizeFlags            aFlags)
+{
+  // Use basic shrink-wrapping as a default implementation.
+  LogicalSize result(aWM, 0xdeadbeef, NS_UNCONSTRAINEDSIZE);
+
+  // don't bother setting it if the result won't be used
+  if (StylePosition()->ISize(aWM).GetUnit() == eStyleUnit_Auto) {
+    nscoord availBased = aAvailableISize - aMargin.ISize(aWM) -
+                         aBorder.ISize(aWM) - aPadding.ISize(aWM);
+    result.ISize(aWM) = ShrinkWidthToFit(aRenderingContext, availBased, aFlags);
+  }
+  return result;
+}
+
+nscoord
+nsFrame::ShrinkWidthToFit(nsRenderingContext* aRenderingContext,
+                          nscoord             aISizeInCB,
+                          ComputeSizeFlags    aFlags)
+{
+  // If we're a container for font size inflation, then shrink
+  // wrapping inside of us should not apply font size inflation.
+  AutoMaybeDisableFontInflation an(this);
+
+  nscoord result;
+  nscoord minISize = GetMinISize(aRenderingContext);
+  if (minISize > aISizeInCB) {
+    const bool clamp = aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize;
+    result = MOZ_UNLIKELY(clamp) ? aISizeInCB : minISize;
+  } else {
+    nscoord prefISize = GetPrefISize(aRenderingContext);
+    if (prefISize > aISizeInCB) {
+      result = aISizeInCB;
+    } else {
+      result = prefISize;
+    }
+  }
+  return result;
+}
+
+nscoord
+nsIFrame::ComputeISizeValue(nsRenderingContext* aRenderingContext,
+                            nscoord             aContainingBlockISize,
+                            nscoord             aContentEdgeToBoxSizing,
+                            nscoord             aBoxSizingToMarginEdge,
+                            const nsStyleCoord& aCoord,
+                            ComputeSizeFlags    aFlags)
+{
+  NS_PRECONDITION(aRenderingContext, "non-null rendering context expected");
+  LAYOUT_WARN_IF_FALSE(aContainingBlockISize != NS_UNCONSTRAINEDSIZE,
+                       "have unconstrained inline-size; this should only result from "
+                       "very large sizes, not attempts at intrinsic inline-size "
+                       "calculation");
+  NS_PRECONDITION(aContainingBlockISize >= 0,
+                  "inline-size less than zero");
+
+  nscoord result;
+  if (aCoord.IsCoordPercentCalcUnit()) {
+    result = nsRuleNode::ComputeCoordPercentCalc(aCoord,
+                                                 aContainingBlockISize);
+    // The result of a calc() expression might be less than 0; we
+    // should clamp at runtime (below).  (Percentages and coords that
+    // are less than 0 have already been dropped by the parser.)
+    result -= aContentEdgeToBoxSizing;
+  } else {
+    MOZ_ASSERT(eStyleUnit_Enumerated == aCoord.GetUnit());
+    // If 'this' is a container for font size inflation, then shrink
+    // wrapping inside of it should not apply font size inflation.
+    AutoMaybeDisableFontInflation an(this);
+
+    int32_t val = aCoord.GetIntValue();
+    switch (val) {
+      case NS_STYLE_WIDTH_MAX_CONTENT:
+        result = GetPrefISize(aRenderingContext);
+        NS_ASSERTION(result >= 0, "inline-size less than zero");
+        break;
+      case NS_STYLE_WIDTH_MIN_CONTENT:
+        result = GetMinISize(aRenderingContext);
+        NS_ASSERTION(result >= 0, "inline-size less than zero");
+        if (MOZ_UNLIKELY(aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize)) {
+          auto available = aContainingBlockISize -
+                           (aBoxSizingToMarginEdge + aContentEdgeToBoxSizing);
+          result = std::min(available, result);
+        }
+        break;
+      case NS_STYLE_WIDTH_FIT_CONTENT:
+        {
+          nscoord pref = GetPrefISize(aRenderingContext),
+                   min = GetMinISize(aRenderingContext),
+                  fill = aContainingBlockISize -
+                         (aBoxSizingToMarginEdge + aContentEdgeToBoxSizing);
+          if (MOZ_UNLIKELY(aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize)) {
+            min = std::min(min, fill);
+          }
+          result = std::max(min, std::min(pref, fill));
+          NS_ASSERTION(result >= 0, "inline-size less than zero");
+        }
+        break;
+      case NS_STYLE_WIDTH_AVAILABLE:
+        result = aContainingBlockISize -
+                 (aBoxSizingToMarginEdge + aContentEdgeToBoxSizing);
+    }
+  }
+
+  return std::max(0, result);
+}
+
+void
+nsFrame::DidReflow(nsPresContext*           aPresContext,
+                   const ReflowInput*  aReflowInput,
+                   nsDidReflowStatus         aStatus)
+{
+  NS_FRAME_TRACE_MSG(NS_FRAME_TRACE_CALLS,
+                     ("nsFrame::DidReflow: aStatus=%d", static_cast<uint32_t>(aStatus)));
+
+  nsSVGEffects::InvalidateDirectRenderingObservers(this, nsSVGEffects::INVALIDATE_REFLOW);
+
+  if (nsDidReflowStatus::FINISHED == aStatus) {
+    mState &= ~(NS_FRAME_IN_REFLOW | NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
+                NS_FRAME_HAS_DIRTY_CHILDREN);
+  }
+
+  // Notify the percent bsize observer if there is a percent bsize.
+  // The observer may be able to initiate another reflow with a computed
+  // bsize. This happens in the case where a table cell has no computed
+  // bsize but can fabricate one when the cell bsize is known.
+  if (aReflowInput && aReflowInput->mPercentBSizeObserver &&
+      !GetPrevInFlow()) {
+    const nsStyleCoord &bsize =
+      aReflowInput->mStylePosition->BSize(aReflowInput->GetWritingMode());
+    if (bsize.HasPercent()) {
+      aReflowInput->mPercentBSizeObserver->NotifyPercentBSize(*aReflowInput);
+    }
+  }
+
+  aPresContext->ReflowedFrame();
+}
+
+void
+nsFrame::FinishReflowWithAbsoluteFrames(nsPresContext*           aPresContext,
+                                        ReflowOutput&     aDesiredSize,
+                                        const ReflowInput& aReflowInput,
+                                        nsReflowStatus&          aStatus,
+                                        bool                     aConstrainBSize)
+{
+  ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus, aConstrainBSize);
+
+  FinishAndStoreOverflow(&aDesiredSize);
+}
+
+void
+nsFrame::ReflowAbsoluteFrames(nsPresContext*           aPresContext,
+                              ReflowOutput&     aDesiredSize,
+                              const ReflowInput& aReflowInput,
+                              nsReflowStatus&          aStatus,
+                              bool                     aConstrainBSize)
+{
+  if (HasAbsolutelyPositionedChildren()) {
+    nsAbsoluteContainingBlock* absoluteContainer = GetAbsoluteContainingBlock();
+
+    // Let the absolutely positioned container reflow any absolutely positioned
+    // child frames that need to be reflowed
+
+    // The containing block for the abs pos kids is formed by our padding edge.
+    nsMargin usedBorder = GetUsedBorder();
+    nscoord containingBlockWidth =
+      std::max(0, aDesiredSize.Width() - usedBorder.LeftRight());
+    nscoord containingBlockHeight =
+      std::max(0, aDesiredSize.Height() - usedBorder.TopBottom());
+    nsContainerFrame* container = do_QueryFrame(this);
+    NS_ASSERTION(container, "Abs-pos children only supported on container frames for now");
+
+    nsRect containingBlock(0, 0, containingBlockWidth, containingBlockHeight);
+    AbsPosReflowFlags flags =
+      AbsPosReflowFlags::eCBWidthAndHeightChanged; // XXX could be optimized
+    if (aConstrainBSize) {
+      flags |= AbsPosReflowFlags::eConstrainHeight;
+    }
+    absoluteContainer->Reflow(container, aPresContext, aReflowInput, aStatus,
+                              containingBlock, flags,
+                              &aDesiredSize.mOverflowAreas);
+  }
+}
+
+void
+nsFrame::PushDirtyBitToAbsoluteFrames()
+{
+  if (!(GetStateBits() & NS_FRAME_IS_DIRTY)) {
+    return;  // No dirty bit to push.
+  }
+  if (!HasAbsolutelyPositionedChildren()) {
+    return;  // No absolute children to push to.
+  }
+  GetAbsoluteContainingBlock()->MarkAllFramesDirty();
+}
+
+/* virtual */ bool
+nsFrame::CanContinueTextRun() const
+{
+  // By default, a frame will *not* allow a text run to be continued
+  // through it.
+  return false;
+}
+
+void
+nsFrame::Reflow(nsPresContext*          aPresContext,
+                ReflowOutput&     aDesiredSize,
+                const ReflowInput& aReflowInput,
+                nsReflowStatus&          aStatus)
+{
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("nsFrame");
+  aDesiredSize.ClearSize();
+  aStatus = NS_FRAME_COMPLETE;
+  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+nsresult
+nsFrame::CharacterDataChanged(CharacterDataChangeInfo* aInfo)
+{
+  NS_NOTREACHED("should only be called for text frames");
+  return NS_OK;
+}
+
+nsresult
+nsFrame::AttributeChanged(int32_t         aNameSpaceID,
+                          nsIAtom*        aAttribute,
+                          int32_t         aModType)
+{
+  return NS_OK;
+}
+
+// Flow member functions
+
+nsSplittableType
+nsFrame::GetSplittableType() const
+{
+  return NS_FRAME_NOT_SPLITTABLE;
+}
+
+nsIFrame* nsFrame::GetPrevContinuation() const
+{
+  return nullptr;
+}
+
+void
+nsFrame::SetPrevContinuation(nsIFrame* aPrevContinuation)
+{
+  MOZ_ASSERT(false, "not splittable");
+}
+
+nsIFrame* nsFrame::GetNextContinuation() const
+{
+  return nullptr;
+}
+
+void
+nsFrame::SetNextContinuation(nsIFrame*)
+{
+  MOZ_ASSERT(false, "not splittable");
+}
+
+nsIFrame* nsFrame::GetPrevInFlowVirtual() const
+{
+  return nullptr;
+}
+
+void
+nsFrame::SetPrevInFlow(nsIFrame* aPrevInFlow)
+{
+  MOZ_ASSERT(false, "not splittable");
+}
+
+nsIFrame* nsFrame::GetNextInFlowVirtual() const
+{
+  return nullptr;
+}
+
+void
+nsFrame::SetNextInFlow(nsIFrame*)
+{
+  MOZ_ASSERT(false, "not splittable");
+}
+
+nsIFrame* nsIFrame::GetTailContinuation()
+{
+  nsIFrame* frame = this;
+  while (frame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER) {
+    frame = frame->GetPrevContinuation();
+    NS_ASSERTION(frame, "first continuation can't be overflow container");
+  }
+  for (nsIFrame* next = frame->GetNextContinuation();
+       next && !(next->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER);
+       next = frame->GetNextContinuation())  {
+    frame = next;
+  }
+  NS_POSTCONDITION(frame, "illegal state in continuation chain.");
+  return frame;
+}
+
+NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(ViewProperty, nsView)
+
+// Associated view object
+nsView*
+nsIFrame::GetView() const
+{
+  // Check the frame state bit and see if the frame has a view
+  if (!(GetStateBits() & NS_FRAME_HAS_VIEW))
+    return nullptr;
+
+  // Check for a property on the frame
+  nsView* value = Properties().Get(ViewProperty());
+  NS_ASSERTION(value, "frame state bit was set but frame has no view");
+  return value;
+}
+
+nsresult
+nsIFrame::SetView(nsView* aView)
+{
+  if (aView) {
+    aView->SetFrame(this);
+
+#ifdef DEBUG
+    nsIAtom* frameType = GetType();
+    NS_ASSERTION(frameType == nsGkAtoms::scrollFrame ||
+                 frameType == nsGkAtoms::subDocumentFrame ||
+                 frameType == nsGkAtoms::listControlFrame ||
+                 frameType == nsGkAtoms::objectFrame ||
+                 frameType == nsGkAtoms::viewportFrame ||
+                 frameType == nsGkAtoms::menuPopupFrame,
+                 "Only specific frame types can have an nsView");
+#endif
+
+    // Set a property on the frame
+    Properties().Set(ViewProperty(), aView);
+
+    // Set the frame state bit that says the frame has a view
+    AddStateBits(NS_FRAME_HAS_VIEW);
+
+    // Let all of the ancestors know they have a descendant with a view.
+    for (nsIFrame* f = GetParent();
+         f && !(f->GetStateBits() & NS_FRAME_HAS_CHILD_WITH_VIEW);
+         f = f->GetParent())
+      f->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
+  }
+
+  return NS_OK;
+}
+
+// Find the first geometric parent that has a view
+nsIFrame* nsIFrame::GetAncestorWithView() const
+{
+  for (nsIFrame* f = GetParent(); nullptr != f; f = f->GetParent()) {
+    if (f->HasView()) {
+      return f;
+    }
+  }
+  return nullptr;
+}
+
+nsPoint nsIFrame::GetOffsetTo(const nsIFrame* aOther) const
+{
+  NS_PRECONDITION(aOther,
+                  "Must have frame for destination coordinate system!");
+
+  NS_ASSERTION(PresContext() == aOther->PresContext(),
+               "GetOffsetTo called on frames in different documents");
+
+  nsPoint offset(0, 0);
+  const nsIFrame* f;
+  for (f = this; f != aOther && f; f = f->GetParent()) {
+    offset += f->GetPosition();
+  }
+
+  if (f != aOther) {
+    // Looks like aOther wasn't an ancestor of |this|.  So now we have
+    // the root-frame-relative position of |this| in |offset|.  Convert back
+    // to the coordinates of aOther
+    while (aOther) {
+      offset -= aOther->GetPosition();
+      aOther = aOther->GetParent();
+    }
+  }
+
+  return offset;
+}
+
+nsPoint nsIFrame::GetOffsetToCrossDoc(const nsIFrame* aOther) const
+{
+  return GetOffsetToCrossDoc(aOther, PresContext()->AppUnitsPerDevPixel());
+}
+
+nsPoint
+nsIFrame::GetOffsetToCrossDoc(const nsIFrame* aOther, const int32_t aAPD) const
+{
+  NS_PRECONDITION(aOther,
+                  "Must have frame for destination coordinate system!");
+  NS_ASSERTION(PresContext()->GetRootPresContext() ==
+                 aOther->PresContext()->GetRootPresContext(),
+               "trying to get the offset between frames in different document "
+               "hierarchies?");
+  if (PresContext()->GetRootPresContext() !=
+        aOther->PresContext()->GetRootPresContext()) {
+    // crash right away, we are almost certainly going to crash anyway.
+    NS_RUNTIMEABORT("trying to get the offset between frames in different "
+                    "document hierarchies?");
+  }
+
+  const nsIFrame* root = nullptr;
+  // offset will hold the final offset
+  // docOffset holds the currently accumulated offset at the current APD, it
+  // will be converted and added to offset when the current APD changes.
+  nsPoint offset(0, 0), docOffset(0, 0);
+  const nsIFrame* f = this;
+  int32_t currAPD = PresContext()->AppUnitsPerDevPixel();
+  while (f && f != aOther) {
+    docOffset += f->GetPosition();
+    nsIFrame* parent = f->GetParent();
+    if (parent) {
+      f = parent;
+    } else {
+      nsPoint newOffset(0, 0);
+      root = f;
+      f = nsLayoutUtils::GetCrossDocParentFrame(f, &newOffset);
+      int32_t newAPD = f ? f->PresContext()->AppUnitsPerDevPixel() : 0;
+      if (!f || newAPD != currAPD) {
+        // Convert docOffset to the right APD and add it to offset.
+        offset += docOffset.ScaleToOtherAppUnits(currAPD, aAPD);
+        docOffset.x = docOffset.y = 0;
+      }
+      currAPD = newAPD;
+      docOffset += newOffset;
+    }
+  }
+  if (f == aOther) {
+    offset += docOffset.ScaleToOtherAppUnits(currAPD, aAPD);
+  } else {
+    // Looks like aOther wasn't an ancestor of |this|.  So now we have
+    // the root-document-relative position of |this| in |offset|. Subtract the
+    // root-document-relative position of |aOther| from |offset|.
+    // This call won't try to recurse again because root is an ancestor of
+    // aOther.
+    nsPoint negOffset = aOther->GetOffsetToCrossDoc(root, aAPD);
+    offset -= negOffset;
+  }
+
+  return offset;
+}
+
+nsIntRect nsIFrame::GetScreenRect() const
+{
+  return GetScreenRectInAppUnits().ToNearestPixels(PresContext()->AppUnitsPerCSSPixel());
+}
+
+nsRect nsIFrame::GetScreenRectInAppUnits() const
+{
+  nsPresContext* presContext = PresContext();
+  nsIFrame* rootFrame =
+    presContext->PresShell()->FrameManager()->GetRootFrame();
+  nsPoint rootScreenPos(0, 0);
+  nsPoint rootFrameOffsetInParent(0, 0);
+  nsIFrame* rootFrameParent =
+    nsLayoutUtils::GetCrossDocParentFrame(rootFrame, &rootFrameOffsetInParent);
+  if (rootFrameParent) {
+    nsRect parentScreenRectAppUnits = rootFrameParent->GetScreenRectInAppUnits();
+    nsPresContext* parentPresContext = rootFrameParent->PresContext();
+    double parentScale = double(presContext->AppUnitsPerDevPixel())/
+        parentPresContext->AppUnitsPerDevPixel();
+    nsPoint rootPt = parentScreenRectAppUnits.TopLeft() + rootFrameOffsetInParent;
+    rootScreenPos.x = NS_round(parentScale*rootPt.x);
+    rootScreenPos.y = NS_round(parentScale*rootPt.y);
+  } else {
+    nsCOMPtr<nsIWidget> rootWidget;
+    presContext->PresShell()->GetViewManager()->GetRootWidget(getter_AddRefs(rootWidget));
+    if (rootWidget) {
+      LayoutDeviceIntPoint rootDevPx = rootWidget->WidgetToScreenOffset();
+      rootScreenPos.x = presContext->DevPixelsToAppUnits(rootDevPx.x);
+      rootScreenPos.y = presContext->DevPixelsToAppUnits(rootDevPx.y);
+    }
+  }
+
+  return nsRect(rootScreenPos + GetOffsetTo(rootFrame), GetSize());
+}
+
+// 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
+nsIFrame::GetOffsetFromView(nsPoint& aOffset, nsView** aView) const
+{
+  NS_PRECONDITION(nullptr != aView, "null OUT parameter pointer");
+  nsIFrame* frame = const_cast<nsIFrame*>(this);
+
+  *aView = nullptr;
+  aOffset.MoveTo(0, 0);
+  do {
+    aOffset += frame->GetPosition();
+    frame = frame->GetParent();
+  } while (frame && !frame->HasView());
+
+  if (frame) {
+    *aView = frame->GetView();
+  }
+}
+
+nsIWidget*
+nsIFrame::GetNearestWidget() const
+{
+  return GetClosestView()->GetNearestWidget(nullptr);
+}
+
+nsIWidget*
+nsIFrame::GetNearestWidget(nsPoint& aOffset) const
+{
+  nsPoint offsetToView;
+  nsPoint offsetToWidget;
+  nsIWidget* widget =
+    GetClosestView(&offsetToView)->GetNearestWidget(&offsetToWidget);
+  aOffset = offsetToView + offsetToWidget;
+  return widget;
+}
+
+nsIAtom*
+nsFrame::GetType() const
+{
+  return nullptr;
+}
+
+bool
+nsIFrame::IsLeaf() const
+{
+  return true;
+}
+
+Matrix4x4
+nsIFrame::GetTransformMatrix(const nsIFrame* aStopAtAncestor,
+                             nsIFrame** aOutAncestor)
+{
+  NS_PRECONDITION(aOutAncestor, "Need a place to put the ancestor!");
+
+  /* If we're transformed, we want to hand back the combination
+   * transform/translate matrix that will apply our current transform, then
+   * shift us to our parent.
+   */
+  if (IsTransformed()) {
+    /* Compute the delta to the parent, which we need because we are converting
+     * coordinates to our parent.
+     */
+    NS_ASSERTION(nsLayoutUtils::GetCrossDocParentFrame(this),
+                 "Cannot transform the viewport frame!");
+    int32_t scaleFactor = PresContext()->AppUnitsPerDevPixel();
+
+    Matrix4x4 result = nsDisplayTransform::GetResultingTransformMatrix(this,
+                         nsPoint(0,0), scaleFactor,
+                         nsDisplayTransform::INCLUDE_PERSPECTIVE|nsDisplayTransform::OFFSET_BY_ORIGIN,
+                         nullptr);
+    *aOutAncestor = nsLayoutUtils::GetCrossDocParentFrame(this);
+    nsPoint delta = GetOffsetToCrossDoc(*aOutAncestor);
+    /* Combine the raw transform with a translation to our parent. */
+    result.PostTranslate(NSAppUnitsToFloatPixels(delta.x, scaleFactor),
+                         NSAppUnitsToFloatPixels(delta.y, scaleFactor),
+                         0.0f);
+
+    return result;
+  }
+
+  if (nsLayoutUtils::IsPopup(this) &&
+      GetType() == nsGkAtoms::listControlFrame) {
+    nsPresContext* presContext = PresContext();
+    nsIFrame* docRootFrame = presContext->PresShell()->GetRootFrame();
+
+    // Compute a matrix that transforms from the popup widget to the toplevel
+    // widget. We use the widgets because they're the simplest and most
+    // accurate approach --- this should work no matter how the widget position
+    // was chosen.
+    nsIWidget* widget = GetView()->GetWidget();
+    nsPresContext* rootPresContext = PresContext()->GetRootPresContext();
+    // Maybe the widget hasn't been created yet? Popups without widgets are
+    // treated as regular frames. That should work since they'll be rendered
+    // as part of the page if they're rendered at all.
+    if (widget && rootPresContext) {
+      nsIWidget* toplevel = rootPresContext->GetNearestWidget();
+      if (toplevel) {
+        LayoutDeviceIntRect screenBounds = widget->GetClientBounds();
+        LayoutDeviceIntRect toplevelScreenBounds = toplevel->GetClientBounds();
+        LayoutDeviceIntPoint translation =
+          screenBounds.TopLeft() - toplevelScreenBounds.TopLeft();
+
+        Matrix4x4 transformToTop;
+        transformToTop._41 = translation.x;
+        transformToTop._42 = translation.y;
+
+        *aOutAncestor = docRootFrame;
+        Matrix4x4 docRootTransformToTop =
+          nsLayoutUtils::GetTransformToAncestor(docRootFrame, nullptr);
+        if (docRootTransformToTop.IsSingular()) {
+          NS_WARNING("Containing document is invisible, we can't compute a valid transform");
+        } else {
+          docRootTransformToTop.Invert();
+          return transformToTop * docRootTransformToTop;
+        }
+      }
+    }
+  }
+
+  *aOutAncestor = nsLayoutUtils::GetCrossDocParentFrame(this);
+
+  /* Otherwise, we're not transformed.  In that case, we'll walk up the frame
+   * tree until we either hit the root frame or something that may be
+   * transformed.  We'll then change coordinates into that frame, since we're
+   * guaranteed that nothing in-between can be transformed.  First, however,
+   * we have to check to see if we have a parent.  If not, we'll set the
+   * outparam to null (indicating that there's nothing left) and will hand back
+   * the identity matrix.
+   */
+  if (!*aOutAncestor)
+    return Matrix4x4();
+
+  /* Keep iterating while the frame can't possibly be transformed. */
+  while (!(*aOutAncestor)->IsTransformed() &&
+         !nsLayoutUtils::IsPopup(*aOutAncestor) &&
+         *aOutAncestor != aStopAtAncestor) {
+    /* If no parent, stop iterating.  Otherwise, update the ancestor. */
+    nsIFrame* parent = nsLayoutUtils::GetCrossDocParentFrame(*aOutAncestor);
+    if (!parent)
+      break;
+
+    *aOutAncestor = parent;
+  }
+
+  NS_ASSERTION(*aOutAncestor, "Somehow ended up with a null ancestor...?");
+
+  /* Translate from this frame to our ancestor, if it exists.  That's the
+   * entire transform, so we're done.
+   */
+  nsPoint delta = GetOffsetToCrossDoc(*aOutAncestor);
+  int32_t scaleFactor = PresContext()->AppUnitsPerDevPixel();
+  return Matrix4x4::Translation(NSAppUnitsToFloatPixels(delta.x, scaleFactor),
+                                NSAppUnitsToFloatPixels(delta.y, scaleFactor),
+                                0.0f);
+}
+
+static void InvalidateRenderingObservers(nsIFrame* aFrame)
+{
+  nsSVGEffects::InvalidateDirectRenderingObservers(aFrame);
+  nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(aFrame);
+  nsIFrame* parent = aFrame;
+  while (parent != displayRoot &&
+         (parent = nsLayoutUtils::GetCrossDocParentFrame(parent)) &&
+         !parent->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
+    nsSVGEffects::InvalidateDirectRenderingObservers(parent);
+  }
+}
+
+void
+SchedulePaintInternal(nsIFrame* aFrame, nsIFrame::PaintType aType = nsIFrame::PAINT_DEFAULT)
+{
+  nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(aFrame);
+  nsPresContext* pres = displayRoot->PresContext()->GetRootPresContext();
+
+  // No need to schedule a paint for an external document since they aren't
+  // painted directly.
+  if (!pres || (pres->Document() && pres->Document()->IsResourceDoc())) {
+    return;
+  }
+  if (!pres->GetContainerWeak()) {
+    NS_WARNING("Shouldn't call SchedulePaint in a detached pres context");
+    return;
+  }
+
+  pres->PresShell()->ScheduleViewManagerFlush(aType == nsIFrame::PAINT_DELAYED_COMPRESS ?
+                                              nsIPresShell::PAINT_DELAYED_COMPRESS :
+                                              nsIPresShell::PAINT_DEFAULT);
+
+  if (aType == nsIFrame::PAINT_DELAYED_COMPRESS) {
+    return;
+  }
+
+  if (aType == nsIFrame::PAINT_DEFAULT) {
+    displayRoot->AddStateBits(NS_FRAME_UPDATE_LAYER_TREE);
+  }
+  nsIPresShell* shell = aFrame->PresContext()->PresShell();
+  if (shell) {
+    shell->AddInvalidateHiddenPresShellObserver(pres->RefreshDriver());
+  }
+}
+
+static void InvalidateFrameInternal(nsIFrame *aFrame, bool aHasDisplayItem = true)
+{
+  if (aHasDisplayItem) {
+    aFrame->AddStateBits(NS_FRAME_NEEDS_PAINT);
+  }
+  nsSVGEffects::InvalidateDirectRenderingObservers(aFrame);
+  bool needsSchedulePaint = false;
+  if (nsLayoutUtils::IsPopup(aFrame)) {
+    needsSchedulePaint = true;
+  } else {
+    nsIFrame *parent = nsLayoutUtils::GetCrossDocParentFrame(aFrame);
+    while (parent && !parent->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
+      if (aHasDisplayItem && !parent->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
+        parent->AddStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT);
+      }
+      nsSVGEffects::InvalidateDirectRenderingObservers(parent);
+
+      // If we're inside a popup, then we need to make sure that we
+      // call schedule paint so that the NS_FRAME_UPDATE_LAYER_TREE
+      // flag gets added to the popup display root frame.
+      if (nsLayoutUtils::IsPopup(parent)) {
+        needsSchedulePaint = true;
+        break;
+      }
+      parent = nsLayoutUtils::GetCrossDocParentFrame(parent);
+    }
+    if (!parent) {
+      needsSchedulePaint = true;
+    }
+  }
+  if (!aHasDisplayItem) {
+    return;
+  }
+  if (needsSchedulePaint) {
+    SchedulePaintInternal(aFrame);
+  }
+  if (aFrame->HasAnyStateBits(NS_FRAME_HAS_INVALID_RECT)) {
+    aFrame->Properties().Delete(nsIFrame::InvalidationRect());
+    aFrame->RemoveStateBits(NS_FRAME_HAS_INVALID_RECT);
+  }
+}
+
+void
+nsIFrame::InvalidateFrameSubtree(uint32_t aDisplayItemKey)
+{
+  bool hasDisplayItem = 
+    !aDisplayItemKey || FrameLayerBuilder::HasRetainedDataFor(this, aDisplayItemKey);
+  InvalidateFrame(aDisplayItemKey);
+
+  if (HasAnyStateBits(NS_FRAME_ALL_DESCENDANTS_NEED_PAINT) || !hasDisplayItem) {
+    return;
+  }
+
+  AddStateBits(NS_FRAME_ALL_DESCENDANTS_NEED_PAINT);
+  
+  AutoTArray<nsIFrame::ChildList,4> childListArray;
+  GetCrossDocChildLists(&childListArray);
+
+  nsIFrame::ChildListArrayIterator lists(childListArray);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      childFrames.get()->InvalidateFrameSubtree();
+    }
+  }
+}
+
+void
+nsIFrame::ClearInvalidationStateBits()
+{
+  if (HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
+    AutoTArray<nsIFrame::ChildList,4> childListArray;
+    GetCrossDocChildLists(&childListArray);
+
+    nsIFrame::ChildListArrayIterator lists(childListArray);
+    for (; !lists.IsDone(); lists.Next()) {
+      nsFrameList::Enumerator childFrames(lists.CurrentList());
+      for (; !childFrames.AtEnd(); childFrames.Next()) {
+        childFrames.get()->ClearInvalidationStateBits();
+      }
+    }
+  }
+
+  RemoveStateBits(NS_FRAME_NEEDS_PAINT | 
+                  NS_FRAME_DESCENDANT_NEEDS_PAINT | 
+                  NS_FRAME_ALL_DESCENDANTS_NEED_PAINT);
+}
+
+void
+nsIFrame::InvalidateFrame(uint32_t aDisplayItemKey)
+{
+  bool hasDisplayItem = 
+    !aDisplayItemKey || FrameLayerBuilder::HasRetainedDataFor(this, aDisplayItemKey);
+  InvalidateFrameInternal(this, hasDisplayItem);
+}
+
+void
+nsIFrame::InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey)
+{
+  bool hasDisplayItem = 
+    !aDisplayItemKey || FrameLayerBuilder::HasRetainedDataFor(this, aDisplayItemKey);
+  bool alreadyInvalid = false;
+  if (!HasAnyStateBits(NS_FRAME_NEEDS_PAINT)) {
+    InvalidateFrameInternal(this, hasDisplayItem);
+  } else {
+    alreadyInvalid = true;
+  } 
+
+  if (!hasDisplayItem) {
+    return;
+  }
+
+  nsRect* rect = Properties().Get(InvalidationRect());
+  if (!rect) {
+    if (alreadyInvalid) {
+      return;
+    }
+    rect = new nsRect();
+    Properties().Set(InvalidationRect(), rect);
+    AddStateBits(NS_FRAME_HAS_INVALID_RECT);
+  }
+
+  *rect = rect->Union(aRect);
+}
+
+/*static*/ uint8_t nsIFrame::sLayerIsPrerenderedDataKey;
+
+static bool
+DoesLayerHaveOutOfDateFrameMetrics(Layer* aLayer)
+{
+  for (uint32_t i = 0; i < aLayer->GetScrollMetadataCount(); i++) {
+    const FrameMetrics& metrics = aLayer->GetFrameMetrics(i);
+    if (!metrics.IsScrollable()) {
+      continue;
+    }
+    nsIScrollableFrame* scrollableFrame =
+      nsLayoutUtils::FindScrollableFrameFor(metrics.GetScrollId());
+    if (!scrollableFrame) {
+      // This shouldn't happen, so let's do the safe thing and trigger a full
+      // paint if it does.
+      return true;
+    }
+    nsPoint scrollPosition = scrollableFrame->GetScrollPosition();
+    if (metrics.GetScrollOffset() != CSSPoint::FromAppUnits(scrollPosition)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool
+DoesLayerOrAncestorsHaveOutOfDateFrameMetrics(Layer* aLayer)
+{
+  for (Layer* layer = aLayer; layer; layer = layer->GetParent()) {
+    if (DoesLayerHaveOutOfDateFrameMetrics(layer)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool
+nsIFrame::TryUpdateTransformOnly(Layer** aLayerResult)
+{
+  Layer* layer = FrameLayerBuilder::GetDedicatedLayer(
+    this, nsDisplayItem::TYPE_TRANSFORM);
+  if (!layer || !layer->HasUserData(LayerIsPrerenderedDataKey())) {
+    // If this layer isn't prerendered or we clip composites to our OS
+    // window, then we can't correctly optimize to an empty
+    // transaction in general.
+    return false;
+  }
+
+  if (DoesLayerOrAncestorsHaveOutOfDateFrameMetrics(layer)) {
+    // At least one scroll frame that can affect the position of this layer
+    // has changed its scroll offset since the last paint. Schedule a full
+    // paint to make sure that this layer's transform and all the frame
+    // metrics that affect it are in sync.
+    return false;
+  }
+
+  gfx::Matrix4x4 transform3d;
+  if (!nsLayoutUtils::GetLayerTransformForFrame(this, &transform3d)) {
+    // We're not able to compute a layer transform that we know would
+    // be used at the next layers transaction, so we can't only update
+    // the transform and will need to schedule an invalidating paint.
+    return false;
+  }
+  gfx::Matrix transform;
+  gfx::Matrix previousTransform;
+  // FIXME/bug 796690 and 796705: in general, changes to 3D
+  // transforms, or transform changes to properties other than
+  // translation, may lead us to choose a different rendering
+  // resolution for our layer.  So if the transform is 3D or has a
+  // non-translation change, bail and schedule an invalidating paint.
+  // (We can often do better than this, for example for scale-down
+  // changes.)
+ static const gfx::Float kError = 0.0001f;
+  if (!transform3d.Is2D(&transform) ||
+      !layer->GetBaseTransform().Is2D(&previousTransform) ||
+      !gfx::FuzzyEqual(transform._11, previousTransform._11, kError) ||
+      !gfx::FuzzyEqual(transform._22, previousTransform._22, kError) ||
+      !gfx::FuzzyEqual(transform._21, previousTransform._21, kError) ||
+      !gfx::FuzzyEqual(transform._12, previousTransform._12, kError)) {
+    return false;
+  }
+  layer->SetBaseTransformForNextTransaction(transform3d);
+  *aLayerResult = layer;
+  return true;
+}
+
+bool 
+nsIFrame::IsInvalid(nsRect& aRect)
+{
+  if (!HasAnyStateBits(NS_FRAME_NEEDS_PAINT)) {
+    return false;
+  }
+  
+  if (HasAnyStateBits(NS_FRAME_HAS_INVALID_RECT)) {
+    nsRect* rect = Properties().Get(InvalidationRect());
+    NS_ASSERTION(rect, "Must have an invalid rect if NS_FRAME_HAS_INVALID_RECT is set!");
+    aRect = *rect;
+  } else {
+    aRect.SetEmpty();
+  }
+  return true;
+}
+
+void
+nsIFrame::SchedulePaint(PaintType aType)
+{
+  InvalidateRenderingObservers(this);
+  SchedulePaintInternal(this, aType);
+}
+
+Layer*
+nsIFrame::InvalidateLayer(uint32_t aDisplayItemKey,
+                          const nsIntRect* aDamageRect,
+                          const nsRect* aFrameDamageRect,
+                          uint32_t aFlags /* = 0 */)
+{
+  NS_ASSERTION(aDisplayItemKey > 0, "Need a key");
+
+  Layer* layer = FrameLayerBuilder::GetDedicatedLayer(this, aDisplayItemKey);
+
+  InvalidateRenderingObservers(this);
+
+  // If the layer is being updated asynchronously, and it's being forwarded
+  // to a compositor, then we don't need to invalidate.
+  if ((aFlags & UPDATE_IS_ASYNC) && layer &&
+      layer->Manager()->GetBackendType() == LayersBackend::LAYERS_CLIENT) {
+    return layer;
+  }
+
+  if (!layer) {
+    if (aFrameDamageRect && aFrameDamageRect->IsEmpty()) {
+      return nullptr;
+    }
+
+    // Plugins can transition from not rendering anything to rendering,
+    // and still only call this. So always invalidate, with specifying
+    // the display item type just in case.
+    //
+    // In the bug 930056, dialer app startup but not shown on the
+    // screen because sometimes we don't have any retainned data
+    // for remote type displayitem and thus Repaint event is not
+    // triggered. So, always invalidate here as well.
+    uint32_t displayItemKey = aDisplayItemKey;
+    if (aDisplayItemKey == nsDisplayItem::TYPE_PLUGIN ||
+        aDisplayItemKey == nsDisplayItem::TYPE_REMOTE) {
+      displayItemKey = 0;
+    }
+
+    if (aFrameDamageRect) {
+      InvalidateFrameWithRect(*aFrameDamageRect, displayItemKey);
+    } else {
+      InvalidateFrame(displayItemKey);
+    }
+
+    return nullptr;
+  }
+
+  if (aDamageRect && aDamageRect->IsEmpty()) {
+    return layer;
+  }
+
+  if (aDamageRect) {
+    layer->AddInvalidRect(*aDamageRect);
+  } else {
+    layer->SetInvalidRectToVisibleRegion();
+  }
+
+  SchedulePaintInternal(this, PAINT_COMPOSITE_ONLY);
+  return layer;
+}
+
+static nsRect
+ComputeEffectsRect(nsIFrame* aFrame, const nsRect& aOverflowRect,
+                   const nsSize& aNewSize)
+{
+  nsRect r = aOverflowRect;
+
+  if (aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT) {
+    // For SVG frames, we only need to account for filters.
+    // TODO: We could also take account of clipPath and mask to reduce the
+    // visual overflow, but that's not essential.
+    if (aFrame->StyleEffects()->HasFilters()) {
+      aFrame->Properties().
+        Set(nsIFrame::PreEffectsBBoxProperty(), new nsRect(r));
+      r = nsSVGUtils::GetPostFilterVisualOverflowRect(aFrame, aOverflowRect);
+    }
+    return r;
+  }
+
+  // box-shadow
+  r.UnionRect(r, nsLayoutUtils::GetBoxShadowRectForFrame(aFrame, aNewSize));
+
+  // border-image-outset.
+  // We need to include border-image-outset because it can cause the
+  // border image to be drawn beyond the border box.
+
+  // (1) It's important we not check whether there's a border-image
+  //     since the style hint for a change in border image doesn't cause
+  //     reflow, and that's probably more important than optimizing the
+  //     overflow areas for the silly case of border-image-outset without
+  //     border-image
+  // (2) It's important that we not check whether the border-image
+  //     is actually loaded, since that would require us to reflow when
+  //     the image loads.
+  const nsStyleBorder* styleBorder = aFrame->StyleBorder();
+  nsMargin outsetMargin = styleBorder->GetImageOutset();
+
+  if (outsetMargin != nsMargin(0, 0, 0, 0)) {
+    nsRect outsetRect(nsPoint(0, 0), aNewSize);
+    outsetRect.Inflate(outsetMargin);
+    r.UnionRect(r, outsetRect);
+  }
+
+  // Note that we don't remove the outlineInnerRect if a frame loses outline
+  // style. That would require an extra property lookup for every frame,
+  // or a new frame state bit to track whether a property had been stored,
+  // or something like that. It's not worth doing that here. At most it's
+  // only one heap-allocated rect per frame and it will be cleaned up when
+  // the frame dies.
+
+  if (nsSVGIntegrationUtils::UsingEffectsForFrame(aFrame)) {
+    aFrame->Properties().
+      Set(nsIFrame::PreEffectsBBoxProperty(), new nsRect(r));
+    r = nsSVGIntegrationUtils::ComputePostEffectsVisualOverflowRect(aFrame, r);
+  }
+
+  return r;
+}
+
+void
+nsIFrame::MovePositionBy(const nsPoint& aTranslation)
+{
+  nsPoint position = GetNormalPosition() + aTranslation;
+
+  const nsMargin* computedOffsets = nullptr;
+  if (IsRelativelyPositioned()) {
+    computedOffsets = Properties().Get(nsIFrame::ComputedOffsetProperty());
+  }
+  ReflowInput::ApplyRelativePositioning(this, computedOffsets ?
+                                              *computedOffsets : nsMargin(),
+                                              &position);
+  SetPosition(position);
+}
+
+nsRect
+nsIFrame::GetNormalRect() const
+{
+  // It might be faster to first check
+  // StyleDisplay()->IsRelativelyPositionedStyle().
+  nsPoint* normalPosition = Properties().Get(NormalPositionProperty());
+  if (normalPosition) {
+    return nsRect(*normalPosition, GetSize());
+  }
+  return GetRect();
+}
+
+nsPoint
+nsIFrame::GetNormalPosition() const
+{
+  // It might be faster to first check
+  // StyleDisplay()->IsRelativelyPositionedStyle().
+  nsPoint* normalPosition = Properties().Get(NormalPositionProperty());
+  if (normalPosition) {
+    return *normalPosition;
+  }
+  return GetPosition();
+}
+
+nsPoint
+nsIFrame::GetPositionIgnoringScrolling()
+{
+  return GetParent() ? GetParent()->GetPositionOfChildIgnoringScrolling(this)
+    : GetPosition();
+}
+
+nsRect
+nsIFrame::GetOverflowRect(nsOverflowType aType) const
+{
+  MOZ_ASSERT(aType == eVisualOverflow || aType == eScrollableOverflow,
+             "unexpected type");
+
+  // Note that in some cases the overflow area might not have been
+  // updated (yet) to reflect any outline set on the frame or the area
+  // of child frames. That's OK because any reflow that updates these
+  // areas will invalidate the appropriate area, so any (mis)uses of
+  // this method will be fixed up.
+
+  if (mOverflow.mType == NS_FRAME_OVERFLOW_LARGE) {
+    // there is an overflow rect, and it's not stored as deltas but as
+    // a separately-allocated rect
+    return static_cast<nsOverflowAreas*>(const_cast<nsIFrame*>(this)->
+             GetOverflowAreasProperty())->Overflow(aType);
+  }
+
+  if (aType == eVisualOverflow &&
+      mOverflow.mType != NS_FRAME_OVERFLOW_NONE) {
+    return GetVisualOverflowFromDeltas();
+  }
+
+  return nsRect(nsPoint(0, 0), GetSize());
+}
+
+nsOverflowAreas
+nsIFrame::GetOverflowAreas() const
+{
+  if (mOverflow.mType == NS_FRAME_OVERFLOW_LARGE) {
+    // there is an overflow rect, and it's not stored as deltas but as
+    // a separately-allocated rect
+    return *const_cast<nsIFrame*>(this)->GetOverflowAreasProperty();
+  }
+
+  return nsOverflowAreas(GetVisualOverflowFromDeltas(),
+                         nsRect(nsPoint(0, 0), GetSize()));
+}
+
+nsOverflowAreas
+nsIFrame::GetOverflowAreasRelativeToSelf() const
+{
+  if (IsTransformed()) {
+    nsOverflowAreas* preTransformOverflows =
+      Properties().Get(PreTransformOverflowAreasProperty());
+    if (preTransformOverflows) {
+      return nsOverflowAreas(preTransformOverflows->VisualOverflow(),
+                             preTransformOverflows->ScrollableOverflow());
+    }
+  }
+  return nsOverflowAreas(GetVisualOverflowRect(),
+                         GetScrollableOverflowRect());
+}
+
+nsRect
+nsIFrame::GetScrollableOverflowRectRelativeToParent() const
+{
+  return GetScrollableOverflowRect() + mRect.TopLeft();
+}
+
+nsRect
+nsIFrame::GetVisualOverflowRectRelativeToParent() const
+{
+  return GetVisualOverflowRect() + mRect.TopLeft();
+}
+
+nsRect
+nsIFrame::GetScrollableOverflowRectRelativeToSelf() const
+{
+  if (IsTransformed()) {
+    nsOverflowAreas* preTransformOverflows =
+      Properties().Get(PreTransformOverflowAreasProperty());
+    if (preTransformOverflows)
+      return preTransformOverflows->ScrollableOverflow();
+  }
+  return GetScrollableOverflowRect();
+}
+
+nsRect
+nsIFrame::GetVisualOverflowRectRelativeToSelf() const
+{
+  if (IsTransformed()) {
+    nsOverflowAreas* preTransformOverflows =
+      Properties().Get(PreTransformOverflowAreasProperty());
+    if (preTransformOverflows)
+      return preTransformOverflows->VisualOverflow();
+  }
+  return GetVisualOverflowRect();
+}
+
+nsRect
+nsIFrame::GetPreEffectsVisualOverflowRect() const
+{
+  nsRect* r = Properties().Get(nsIFrame::PreEffectsBBoxProperty());
+  return r ? *r : GetVisualOverflowRectRelativeToSelf();
+}
+
+bool
+nsIFrame::UpdateOverflow()
+{
+  MOZ_ASSERT(FrameMaintainsOverflow(),
+             "Non-display SVG do not maintain visual overflow rects");
+
+  nsRect rect(nsPoint(0, 0), GetSize());
+  nsOverflowAreas overflowAreas(rect, rect);
+
+  if (!ComputeCustomOverflow(overflowAreas)) {
+    return false;
+  }
+
+  UnionChildOverflow(overflowAreas);
+
+  if (FinishAndStoreOverflow(overflowAreas, GetSize())) {
+    nsView* view = GetView();
+    if (view) {
+      uint32_t flags = GetXULLayoutFlags();
+
+      if ((flags & NS_FRAME_NO_SIZE_VIEW) == 0) {
+        // Make sure the frame's view is properly sized.
+        nsViewManager* vm = view->GetViewManager();
+        vm->ResizeView(view, overflowAreas.VisualOverflow(), true);
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+/* virtual */ bool
+nsFrame::ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas)
+{
+  return true;
+}
+
+/* virtual */ void
+nsFrame::UnionChildOverflow(nsOverflowAreas& aOverflowAreas)
+{
+  if (!DoesClipChildren() &&
+      !(IsXULCollapsed() && (IsXULBoxFrame() || ::IsXULBoxWrapped(this)))) {
+    nsLayoutUtils::UnionChildOverflow(this, aOverflowAreas);
+  }
+}
+
+
+// Define the MAX_FRAME_DEPTH to be the ContentSink's MAX_REFLOW_DEPTH plus
+// 4 for the frames above the document's frames: 
+//  the Viewport, GFXScroll, ScrollPort, and Canvas
+#define MAX_FRAME_DEPTH (MAX_REFLOW_DEPTH+4)
+
+bool
+nsFrame::IsFrameTreeTooDeep(const ReflowInput& aReflowInput,
+                            ReflowOutput& aMetrics,
+                            nsReflowStatus& aStatus)
+{
+  if (aReflowInput.mReflowDepth >  MAX_FRAME_DEPTH) {
+    NS_WARNING("frame tree too deep; setting zero size and returning");
+    mState |= NS_FRAME_TOO_DEEP_IN_FRAME_TREE;
+    ClearOverflowRects();
+    aMetrics.ClearSize();
+    aMetrics.SetBlockStartAscent(0);
+    aMetrics.mCarriedOutBEndMargin.Zero();
+    aMetrics.mOverflowAreas.Clear();
+
+    if (GetNextInFlow()) {
+      // Reflow depth might vary between reflows, so we might have
+      // successfully reflowed and split this frame before.  If so, we
+      // shouldn't delete its continuations.
+      aStatus = NS_FRAME_NOT_COMPLETE;
+    } else {
+      aStatus = NS_FRAME_COMPLETE;
+    }
+
+    return true;
+  }
+  mState &= ~NS_FRAME_TOO_DEEP_IN_FRAME_TREE;
+  return false;
+}
+
+bool
+nsIFrame::IsBlockWrapper() const
+{
+  nsIAtom *pseudoType = StyleContext()->GetPseudo();
+  return (pseudoType == nsCSSAnonBoxes::mozAnonymousBlock ||
+          pseudoType == nsCSSAnonBoxes::mozAnonymousPositionedBlock ||
+          pseudoType == nsCSSAnonBoxes::buttonContent ||
+          pseudoType == nsCSSAnonBoxes::cellContent);
+}
+
+static nsIFrame*
+GetNearestBlockContainer(nsIFrame* frame)
+{
+  // The block wrappers we use to wrap blocks inside inlines aren't
+  // described in the CSS spec.  We need to make them not be containing
+  // blocks.
+  // Since the parent of such a block is either a normal block or
+  // another such pseudo, this shouldn't cause anything bad to happen.
+  // Also the anonymous blocks inside table cells are not containing blocks.
+  while (frame->IsFrameOfType(nsIFrame::eLineParticipant) ||
+         frame->IsBlockWrapper() ||
+         // Table rows are not containing blocks either
+         frame->GetType() == nsGkAtoms::tableRowFrame) {
+    frame = frame->GetParent();
+    NS_ASSERTION(frame, "How come we got to the root frame without seeing a containing block?");
+  }
+  return frame;
+}
+
+nsIFrame*
+nsIFrame::GetContainingBlock(uint32_t aFlags) const
+{
+  if (!GetParent()) {
+    return nullptr;
+  }
+  // MathML frames might have absolute positioning style, but they would
+  // still be in-flow.  So we have to check to make sure that the frame
+  // is really out-of-flow too.
+  nsIFrame* f;
+  if (IsAbsolutelyPositioned() &&
+      (GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
+    f = GetParent(); // the parent is always the containing block
+  } else {
+    f = GetNearestBlockContainer(GetParent());
+  }
+
+  if (aFlags & SKIP_SCROLLED_FRAME && f &&
+      f->StyleContext()->GetPseudo() == nsCSSAnonBoxes::scrolledContent) {
+    f = f->GetParent();
+  }
+  return f;
+}
+
+#ifdef DEBUG_FRAME_DUMP
+
+int32_t nsFrame::ContentIndexInContainer(const nsIFrame* aFrame)
+{
+  int32_t result = -1;
+
+  nsIContent* content = aFrame->GetContent();
+  if (content) {
+    nsIContent* parentContent = content->GetParent();
+    if (parentContent) {
+      result = parentContent->IndexOf(content);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * List a frame tree to stderr. Meant to be called from gdb.
+ */
+void
+DebugListFrameTree(nsIFrame* aFrame)
+{
+  ((nsFrame*)aFrame)->List(stderr);
+}
+
+void
+nsIFrame::ListTag(nsACString& aTo) const
+{
+  ListTag(aTo, this);
+}
+
+/* static */
+void
+nsIFrame::ListTag(nsACString& aTo, const nsIFrame* aFrame) {
+  nsAutoString tmp;
+  aFrame->GetFrameName(tmp);
+  aTo += NS_ConvertUTF16toUTF8(tmp).get();
+  aTo += nsPrintfCString("@%p", static_cast<const void*>(aFrame));
+}
+
+// Debugging
+void
+nsIFrame::ListGeneric(nsACString& aTo, const char* aPrefix, uint32_t aFlags) const
+{
+  aTo =+ aPrefix;
+  ListTag(aTo);
+  if (HasView()) {
+    aTo += nsPrintfCString(" [view=%p]", static_cast<void*>(GetView()));
+  }
+  if (GetNextSibling()) {
+    aTo += nsPrintfCString(" next=%p", static_cast<void*>(GetNextSibling()));
+  }
+  if (GetPrevContinuation()) {
+    bool fluid = GetPrevInFlow() == GetPrevContinuation();
+    aTo += nsPrintfCString(" prev-%s=%p", fluid?"in-flow":"continuation",
+            static_cast<void*>(GetPrevContinuation()));
+  }
+  if (GetNextContinuation()) {
+    bool fluid = GetNextInFlow() == GetNextContinuation();
+    aTo += nsPrintfCString(" next-%s=%p", fluid?"in-flow":"continuation",
+            static_cast<void*>(GetNextContinuation()));
+  }
+  void* IBsibling = Properties().Get(IBSplitSibling());
+  if (IBsibling) {
+    aTo += nsPrintfCString(" IBSplitSibling=%p", IBsibling);
+  }
+  void* IBprevsibling = Properties().Get(IBSplitPrevSibling());
+  if (IBprevsibling) {
+    aTo += nsPrintfCString(" IBSplitPrevSibling=%p", IBprevsibling);
+  }
+  aTo += nsPrintfCString(" {%d,%d,%d,%d}", mRect.x, mRect.y, mRect.width, mRect.height);
+
+  mozilla::WritingMode wm = GetWritingMode();
+  if (wm.IsVertical() || !wm.IsBidiLTR()) {
+    aTo += nsPrintfCString(" wm=%s: logical size={%d,%d}", wm.DebugString(),
+                           ISize(), BSize());
+  }
+
+  nsIFrame* parent = GetParent();
+  if (parent) {
+    WritingMode pWM = parent->GetWritingMode();
+    if (pWM.IsVertical() || !pWM.IsBidiLTR()) {
+      nsSize containerSize = parent->mRect.Size();
+      LogicalRect lr(pWM, mRect, containerSize);
+      aTo += nsPrintfCString(" parent wm=%s, cs={%d,%d}, "
+                             " logicalRect={%d,%d,%d,%d}",
+                             pWM.DebugString(),
+                             containerSize.width, containerSize.height,
+                             lr.IStart(pWM), lr.BStart(pWM),
+                             lr.ISize(pWM), lr.BSize(pWM));
+    }
+  }
+  nsIFrame* f = const_cast<nsIFrame*>(this);
+  if (f->HasOverflowAreas()) {
+    nsRect vo = f->GetVisualOverflowRect();
+    if (!vo.IsEqualEdges(mRect)) {
+      aTo += nsPrintfCString(" vis-overflow=%d,%d,%d,%d", vo.x, vo.y, vo.width, vo.height);
+    }
+    nsRect so = f->GetScrollableOverflowRect();
+    if (!so.IsEqualEdges(mRect)) {
+      aTo += nsPrintfCString(" scr-overflow=%d,%d,%d,%d", so.x, so.y, so.width, so.height);
+    }
+  }
+  if (0 != mState) {
+    aTo += nsPrintfCString(" [state=%016llx]", (unsigned long long)mState);
+  }
+  if (IsTransformed()) {
+    aTo += nsPrintfCString(" transformed");
+  }
+  if (ChildrenHavePerspective()) {
+    aTo += nsPrintfCString(" perspective");
+  }
+  if (Extend3DContext()) {
+    aTo += nsPrintfCString(" preserves-3d-children");
+  }
+  if (Combines3DTransformWithAncestors()) {
+    aTo += nsPrintfCString(" preserves-3d");
+  }
+  if (mContent) {
+    aTo += nsPrintfCString(" [content=%p]", static_cast<void*>(mContent));
+  }
+  aTo += nsPrintfCString(" [sc=%p", static_cast<void*>(mStyleContext));
+  if (mStyleContext) {
+    nsIAtom* pseudoTag = mStyleContext->GetPseudo();
+    if (pseudoTag) {
+      nsAutoString atomString;
+      pseudoTag->ToString(atomString);
+      aTo += nsPrintfCString("%s", NS_LossyConvertUTF16toASCII(atomString).get());
+    }
+    if (!mStyleContext->GetParent() ||
+        (GetParent() && GetParent()->StyleContext() != mStyleContext->GetParent())) {
+      aTo += nsPrintfCString("^%p", mStyleContext->GetParent());
+      if (mStyleContext->GetParent()) {
+        aTo += nsPrintfCString("^%p", mStyleContext->GetParent()->GetParent());
+        if (mStyleContext->GetParent()->GetParent()) {
+          aTo += nsPrintfCString("^%p", mStyleContext->GetParent()->GetParent()->GetParent());
+        }
+      }
+    }
+  }
+  aTo += "]";
+}
+
+void
+nsIFrame::List(FILE* out, const char* aPrefix, uint32_t aFlags) const
+{
+  nsCString str;
+  ListGeneric(str, aPrefix, aFlags);
+  fprintf_stderr(out, "%s\n", str.get());
+}
+
+nsresult
+nsFrame::GetFrameName(nsAString& aResult) const
+{
+  return MakeFrameName(NS_LITERAL_STRING("Frame"), aResult);
+}
+
+nsresult
+nsFrame::MakeFrameName(const nsAString& aType, nsAString& aResult) const
+{
+  aResult = aType;
+  if (mContent && !mContent->IsNodeOfType(nsINode::eTEXT)) {
+    nsAutoString buf;
+    mContent->NodeInfo()->NameAtom()->ToString(buf);
+    if (GetType() == nsGkAtoms::subDocumentFrame) {
+      nsAutoString src;
+      mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::src, src);
+      buf.AppendLiteral(" src=");
+      buf.Append(src);
+    }
+    aResult.Append('(');
+    aResult.Append(buf);
+    aResult.Append(')');
+  }
+  char buf[40];
+  SprintfLiteral(buf, "(%d)", ContentIndexInContainer(this));
+  AppendASCIItoUTF16(buf, aResult);
+  return NS_OK;
+}
+
+void
+nsIFrame::DumpFrameTree() const
+{
+  RootFrameList(PresContext(), stderr);
+}
+
+void
+nsIFrame::DumpFrameTreeLimited() const
+{
+  List(stderr);
+}
+
+void
+nsIFrame::RootFrameList(nsPresContext* aPresContext, FILE* out, const char* aPrefix)
+{
+  if (!aPresContext || !out)
+    return;
+
+  nsIPresShell *shell = aPresContext->GetPresShell();
+  if (shell) {
+    nsIFrame* frame = shell->FrameManager()->GetRootFrame();
+    if(frame) {
+      frame->List(out, aPrefix);
+    }
+  }
+}
+#endif
+
+#ifdef DEBUG
+nsFrameState
+nsFrame::GetDebugStateBits() const
+{
+  // We'll ignore these flags for the purposes of comparing frame state:
+  //
+  //   NS_FRAME_EXTERNAL_REFERENCE
+  //     because this is set by the event state manager or the
+  //     caret code when a frame is focused. Depending on whether
+  //     or not the regression tests are run as the focused window
+  //     will make this value vary randomly.
+#define IRRELEVANT_FRAME_STATE_FLAGS NS_FRAME_EXTERNAL_REFERENCE
+
+#define FRAME_STATE_MASK (~(IRRELEVANT_FRAME_STATE_FLAGS))
+
+  return GetStateBits() & FRAME_STATE_MASK;
+}
+
+void
+nsFrame::XMLQuote(nsString& aString)
+{
+  int32_t i, len = aString.Length();
+  for (i = 0; i < len; i++) {
+    char16_t ch = aString.CharAt(i);
+    if (ch == '<') {
+      nsAutoString tmp(NS_LITERAL_STRING("&lt;"));
+      aString.Cut(i, 1);
+      aString.Insert(tmp, i);
+      len += 3;
+      i += 3;
+    }
+    else if (ch == '>') {
+      nsAutoString tmp(NS_LITERAL_STRING("&gt;"));
+      aString.Cut(i, 1);
+      aString.Insert(tmp, i);
+      len += 3;
+      i += 3;
+    }
+    else if (ch == '\"') {
+      nsAutoString tmp(NS_LITERAL_STRING("&quot;"));
+      aString.Cut(i, 1);
+      aString.Insert(tmp, i);
+      len += 5;
+      i += 5;
+    }
+  }
+}
+#endif
+
+bool
+nsIFrame::IsVisibleForPainting(nsDisplayListBuilder* aBuilder) {
+  if (!StyleVisibility()->IsVisible())
+    return false;
+  nsISelection* sel = aBuilder->GetBoundingSelection();
+  return !sel || IsVisibleInSelection(sel);
+}
+
+bool
+nsIFrame::IsVisibleForPainting() {
+  if (!StyleVisibility()->IsVisible())
+    return false;
+
+  nsPresContext* pc = PresContext();
+  if (!pc->IsRenderingOnlySelection())
+    return true;
+
+  nsCOMPtr<nsISelectionController> selcon(do_QueryInterface(pc->PresShell()));
+  if (selcon) {
+    nsCOMPtr<nsISelection> sel;
+    selcon->GetSelection(nsISelectionController::SELECTION_NORMAL,
+                         getter_AddRefs(sel));
+    if (sel)
+      return IsVisibleInSelection(sel);
+  }
+  return true;
+}
+
+bool
+nsIFrame::IsVisibleInSelection(nsDisplayListBuilder* aBuilder) {
+  nsISelection* sel = aBuilder->GetBoundingSelection();
+  return !sel || IsVisibleInSelection(sel);
+}
+
+bool
+nsIFrame::IsVisibleOrCollapsedForPainting(nsDisplayListBuilder* aBuilder) {
+  if (!StyleVisibility()->IsVisibleOrCollapsed())
+    return false;
+  nsISelection* sel = aBuilder->GetBoundingSelection();
+  return !sel || IsVisibleInSelection(sel);
+}
+
+bool
+nsIFrame::IsVisibleInSelection(nsISelection* aSelection)
+{
+  if (!GetContent() || !GetContent()->IsSelectionDescendant()) {
+    return false;
+  }
+  
+  nsCOMPtr<nsIDOMNode> node(do_QueryInterface(mContent));
+  bool vis;
+  nsresult rv = aSelection->ContainsNode(node, true, &vis);
+  return NS_FAILED(rv) || vis;
+}
+
+/* virtual */ bool
+nsFrame::IsEmpty()
+{
+  return false;
+}
+
+bool
+nsIFrame::CachedIsEmpty()
+{
+  NS_PRECONDITION(!(GetStateBits() & NS_FRAME_IS_DIRTY),
+                  "Must only be called on reflowed lines");
+  return IsEmpty();
+}
+
+/* virtual */ bool
+nsFrame::IsSelfEmpty()
+{
+  return false;
+}
+
+nsresult
+nsFrame::GetSelectionController(nsPresContext *aPresContext, nsISelectionController **aSelCon)
+{
+  if (!aPresContext || !aSelCon)
+    return NS_ERROR_INVALID_ARG;
+
+  nsIFrame *frame = this;
+  while (frame && (frame->GetStateBits() & NS_FRAME_INDEPENDENT_SELECTION)) {
+    nsITextControlFrame *tcf = do_QueryFrame(frame);
+    if (tcf) {
+      return tcf->GetOwnedSelectionController(aSelCon);
+    }
+    frame = frame->GetParent();
+  }
+
+  return CallQueryInterface(aPresContext->GetPresShell(), aSelCon);
+}
+
+already_AddRefed<nsFrameSelection>
+nsIFrame::GetFrameSelection()
+{
+  RefPtr<nsFrameSelection> fs =
+    const_cast<nsFrameSelection*>(GetConstFrameSelection());
+  return fs.forget();
+}
+
+const nsFrameSelection*
+nsIFrame::GetConstFrameSelection() const
+{
+  nsIFrame* frame = const_cast<nsIFrame*>(this);
+  while (frame && (frame->GetStateBits() & NS_FRAME_INDEPENDENT_SELECTION)) {
+    nsITextControlFrame* tcf = do_QueryFrame(frame);
+    if (tcf) {
+      return tcf->GetOwnedFrameSelection();
+    }
+    frame = frame->GetParent();
+  }
+
+  return PresContext()->PresShell()->ConstFrameSelection();
+}
+
+#ifdef DEBUG
+nsresult
+nsFrame::DumpRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
+{
+  IndentBy(out, aIndent);
+  fprintf(out, "<frame va=\"%p\" type=\"", (void*)this);
+  nsAutoString name;
+  GetFrameName(name);
+  XMLQuote(name);
+  fputs(NS_LossyConvertUTF16toASCII(name).get(), out);
+  fprintf(out, "\" state=\"%016llx\" parent=\"%p\">\n",
+          (unsigned long long)GetDebugStateBits(), (void*)GetParent());
+
+  aIndent++;
+  DumpBaseRegressionData(aPresContext, out, aIndent);
+  aIndent--;
+
+  IndentBy(out, aIndent);
+  fprintf(out, "</frame>\n");
+
+  return NS_OK;
+}
+
+void
+nsFrame::DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
+{
+  if (GetNextSibling()) {
+    IndentBy(out, aIndent);
+    fprintf(out, "<next-sibling va=\"%p\"/>\n", (void*)GetNextSibling());
+  }
+
+  if (HasView()) {
+    IndentBy(out, aIndent);
+    fprintf(out, "<view va=\"%p\">\n", (void*)GetView());
+    aIndent++;
+    // XXX add in code to dump out view state too...
+    aIndent--;
+    IndentBy(out, aIndent);
+    fprintf(out, "</view>\n");
+  }
+
+  IndentBy(out, aIndent);
+  fprintf(out, "<bbox x=\"%d\" y=\"%d\" w=\"%d\" h=\"%d\"/>\n",
+          mRect.x, mRect.y, mRect.width, mRect.height);
+
+  // Now dump all of the children on all of the child lists
+  ChildListIterator lists(this);
+  for (; !lists.IsDone(); lists.Next()) {
+    IndentBy(out, aIndent);
+    if (lists.CurrentID() != kPrincipalList) {
+      fprintf(out, "<child-list name=\"%s\">\n", mozilla::layout::ChildListName(lists.CurrentID()));
+    }
+    else {
+      fprintf(out, "<child-list>\n");
+    }
+    aIndent++;
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      nsIFrame* kid = childFrames.get();
+      kid->DumpRegressionData(aPresContext, out, aIndent);
+    }
+    aIndent--;
+    IndentBy(out, aIndent);
+    fprintf(out, "</child-list>\n");
+  }
+}
+#endif
+
+bool
+nsIFrame::IsFrameSelected() const
+{
+  NS_ASSERTION(!GetContent() || GetContent()->IsSelectionDescendant(),
+               "use the public IsSelected() instead");
+  return nsRange::IsNodeSelected(GetContent(), 0,
+                                 GetContent()->GetChildCount());
+}
+
+nsresult
+nsFrame::GetPointFromOffset(int32_t inOffset, nsPoint* outPoint)
+{
+  NS_PRECONDITION(outPoint != nullptr, "Null parameter");
+  nsRect contentRect = GetContentRectRelativeToSelf();
+  nsPoint pt = contentRect.TopLeft();
+  if (mContent)
+  {
+    nsIContent* newContent = mContent->GetParent();
+    if (newContent){
+      int32_t newOffset = newContent->IndexOf(mContent);
+
+      // Find the direction of the frame from the EmbeddingLevelProperty,
+      // which is the resolved bidi level set in
+      // nsBidiPresUtils::ResolveParagraph (odd levels = right-to-left).
+      // If the embedding level isn't set, just use the CSS direction
+      // property.
+      bool hasBidiData;
+      FrameBidiData bidiData =
+        Properties().Get(BidiDataProperty(), &hasBidiData);
+      bool isRTL = hasBidiData
+        ? IS_LEVEL_RTL(bidiData.embeddingLevel)
+        : StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
+      if ((!isRTL && inOffset > newOffset) ||
+          (isRTL && inOffset <= newOffset)) {
+        pt = contentRect.TopRight();
+      }
+    }
+  }
+  *outPoint = pt;
+  return NS_OK;
+}
+
+nsresult
+nsFrame::GetCharacterRectsInRange(int32_t aInOffset, int32_t aLength,
+                                  nsTArray<nsRect>& aOutRect)
+{
+  /* no text */
+  return NS_ERROR_FAILURE;
+}
+
+nsresult
+nsFrame::GetChildFrameContainingOffset(int32_t inContentOffset, bool inHint, int32_t* outFrameContentOffset, nsIFrame **outChildFrame)
+{
+  NS_PRECONDITION(outChildFrame && outFrameContentOffset, "Null parameter");
+  *outFrameContentOffset = (int32_t)inHint;
+  //the best frame to reflect any given offset would be a visible frame if possible
+  //i.e. we are looking for a valid frame to place the blinking caret 
+  nsRect rect = GetRect();
+  if (!rect.width || !rect.height)
+  {
+    //if we have a 0 width or height then lets look for another frame that possibly has
+    //the same content.  If we have no frames in flow then just let us return 'this' frame
+    nsIFrame* nextFlow = GetNextInFlow();
+    if (nextFlow)
+      return nextFlow->GetChildFrameContainingOffset(inContentOffset, inHint, outFrameContentOffset, outChildFrame);
+  }
+  *outChildFrame = this;
+  return NS_OK;
+}
+
+//
+// What I've pieced together about this routine:
+// Starting with a block frame (from which a line frame can be gotten)
+// and a line number, drill down and get the first/last selectable
+// frame on that line, depending on aPos->mDirection.
+// aOutSideLimit != 0 means ignore aLineStart, instead work from
+// the end (if > 0) or beginning (if < 0).
+//
+nsresult
+nsFrame::GetNextPrevLineFromeBlockFrame(nsPresContext* aPresContext,
+                                        nsPeekOffsetStruct *aPos,
+                                        nsIFrame *aBlockFrame, 
+                                        int32_t aLineStart, 
+                                        int8_t aOutSideLimit
+                                        )
+{
+  //magic numbers aLineStart will be -1 for end of block 0 will be start of block
+  if (!aBlockFrame || !aPos)
+    return NS_ERROR_NULL_POINTER;
+
+  aPos->mResultFrame = nullptr;
+  aPos->mResultContent = nullptr;
+  aPos->mAttach =
+      aPos->mDirection == eDirNext ? CARET_ASSOCIATE_AFTER : CARET_ASSOCIATE_BEFORE;
+
+  nsAutoLineIterator it = aBlockFrame->GetLineIterator();
+  if (!it)
+    return NS_ERROR_FAILURE;
+  int32_t searchingLine = aLineStart;
+  int32_t countLines = it->GetNumLines();
+  if (aOutSideLimit > 0) //start at end
+    searchingLine = countLines;
+  else if (aOutSideLimit <0)//start at beginning
+    searchingLine = -1;//"next" will be 0  
+  else 
+    if ((aPos->mDirection == eDirPrevious && searchingLine == 0) || 
+       (aPos->mDirection == eDirNext && searchingLine >= (countLines -1) )){
+      //we need to jump to new block frame.
+           return NS_ERROR_FAILURE;
+    }
+  int32_t lineFrameCount;
+  nsIFrame *resultFrame = nullptr;
+  nsIFrame *farStoppingFrame = nullptr; //we keep searching until we find a "this" frame then we go to next line
+  nsIFrame *nearStoppingFrame = nullptr; //if we are backing up from edge, stop here
+  nsIFrame *firstFrame;
+  nsIFrame *lastFrame;
+  nsRect  rect;
+  bool isBeforeFirstFrame, isAfterLastFrame;
+  bool found = false;
+
+  nsresult result = NS_OK;
+  while (!found)
+  {
+    if (aPos->mDirection == eDirPrevious)
+      searchingLine --;
+    else
+      searchingLine ++;
+    if ((aPos->mDirection == eDirPrevious && searchingLine < 0) || 
+       (aPos->mDirection == eDirNext && searchingLine >= countLines ))
+    {
+      //we need to jump to new block frame.
+      return NS_ERROR_FAILURE;
+    }
+    result = it->GetLine(searchingLine, &firstFrame, &lineFrameCount,
+                         rect);
+    if (!lineFrameCount) 
+      continue;
+    if (NS_SUCCEEDED(result)){
+      lastFrame = firstFrame;
+      for (;lineFrameCount > 1;lineFrameCount --){
+        //result = lastFrame->GetNextSibling(&lastFrame, searchingLine);
+        result = it->GetNextSiblingOnLine(lastFrame, searchingLine);
+        if (NS_FAILED(result) || !lastFrame){
+          NS_ERROR("GetLine promised more frames than could be found");
+          return NS_ERROR_FAILURE;
+        }
+      }
+      GetLastLeaf(aPresContext, &lastFrame);
+
+      if (aPos->mDirection == eDirNext){
+        nearStoppingFrame = firstFrame;
+        farStoppingFrame = lastFrame;
+      }
+      else{
+        nearStoppingFrame = lastFrame;
+        farStoppingFrame = firstFrame;
+      }
+      nsPoint offset;
+      nsView * view; //used for call of get offset from view
+      aBlockFrame->GetOffsetFromView(offset,&view);
+      nsPoint newDesiredPos =
+        aPos->mDesiredPos - offset; //get desired position into blockframe coords
+      result = it->FindFrameAt(searchingLine, newDesiredPos, &resultFrame,
+                               &isBeforeFirstFrame, &isAfterLastFrame);
+      if(NS_FAILED(result))
+        continue;
+    }
+
+    if (NS_SUCCEEDED(result) && resultFrame)
+    {
+      //check to see if this is ANOTHER blockframe inside the other one if so then call into its lines
+      nsAutoLineIterator newIt = resultFrame->GetLineIterator();
+      if (newIt)
+      {
+        aPos->mResultFrame = resultFrame;
+        return NS_OK;
+      }
+      //resultFrame is not a block frame
+      result = NS_ERROR_FAILURE;
+
+      nsCOMPtr<nsIFrameEnumerator> frameTraversal;
+      result = NS_NewFrameTraversal(getter_AddRefs(frameTraversal),
+                                    aPresContext, resultFrame,
+                                    ePostOrder,
+                                    false, // aVisual
+                                    aPos->mScrollViewStop,
+                                    false, // aFollowOOFs
+                                    false  // aSkipPopupChecks
+                                    );
+      if (NS_FAILED(result))
+        return result;
+
+      nsIFrame *storeOldResultFrame = resultFrame;
+      while ( !found ){
+        nsPoint point;
+        nsRect tempRect = resultFrame->GetRect();
+        nsPoint offset;
+        nsView * view; //used for call of get offset from view
+        resultFrame->GetOffsetFromView(offset, &view);
+        if (!view) {
+          return NS_ERROR_FAILURE;
+        }
+        if (resultFrame->GetWritingMode().IsVertical()) {
+          point.y = aPos->mDesiredPos.y;
+          point.x = tempRect.width + offset.x;
+        } else {
+          point.y = tempRect.height + offset.y;
+          point.x = aPos->mDesiredPos.x;
+        }
+
+        //special check. if we allow non-text selection then we can allow a hit location to fall before a table.
+        //otherwise there is no way to get and click signal to fall before a table (it being a line iterator itself)
+        nsIPresShell *shell = aPresContext->GetPresShell();
+        if (!shell)
+          return NS_ERROR_FAILURE;
+        int16_t isEditor = shell->GetSelectionFlags();
+        isEditor = isEditor == nsISelectionDisplay::DISPLAY_ALL;
+        if ( isEditor )
+        {
+          if (resultFrame->GetType() == nsGkAtoms::tableWrapperFrame)
+          {
+            if (((point.x - offset.x + tempRect.x)<0) ||  ((point.x - offset.x+ tempRect.x)>tempRect.width))//off left/right side
+            {
+              nsIContent* content = resultFrame->GetContent();
+              if (content)
+              {
+                nsIContent* parent = content->GetParent();
+                if (parent)
+                {
+                  aPos->mResultContent = parent;
+                  aPos->mContentOffset = parent->IndexOf(content);
+                  aPos->mAttach = CARET_ASSOCIATE_BEFORE;
+                  if ((point.x - offset.x+ tempRect.x)>tempRect.width)
+                  {
+                    aPos->mContentOffset++;//go to end of this frame
+                    aPos->mAttach = CARET_ASSOCIATE_AFTER;
+                  }
+                  //result frame is the result frames parent.
+                  aPos->mResultFrame = resultFrame->GetParent();
+                  return NS_POSITION_BEFORE_TABLE;
+                }
+              }
+            }
+          }
+        }
+
+        if (!resultFrame->HasView())
+        {
+          nsView* view;
+          nsPoint offset;
+          resultFrame->GetOffsetFromView(offset, &view);
+          ContentOffsets offsets =
+              resultFrame->GetContentOffsetsFromPoint(point - offset);
+          aPos->mResultContent = offsets.content;
+          aPos->mContentOffset = offsets.offset;
+          aPos->mAttach = offsets.associate;
+          if (offsets.content)
+          {
+            bool selectable;
+            resultFrame->IsSelectable(&selectable, nullptr);
+            if (selectable)
+            {
+              found = true;
+              break;
+            }
+          }
+        }
+
+        if (aPos->mDirection == eDirPrevious && (resultFrame == farStoppingFrame))
+          break;
+        if (aPos->mDirection == eDirNext && (resultFrame == nearStoppingFrame))
+          break;
+        //always try previous on THAT line if that fails go the other way
+        frameTraversal->Prev();
+        resultFrame = frameTraversal->CurrentItem();
+        if (!resultFrame)
+          return NS_ERROR_FAILURE;
+      }
+
+      if (!found){
+        resultFrame = storeOldResultFrame;
+
+        result = NS_NewFrameTraversal(getter_AddRefs(frameTraversal),
+                                      aPresContext, resultFrame,
+                                      eLeaf,
+                                      false, // aVisual
+                                      aPos->mScrollViewStop,
+                                      false, // aFollowOOFs
+                                      false  // aSkipPopupChecks
+                                      );
+      }
+      while ( !found ){
+        nsPoint point = aPos->mDesiredPos;
+        nsView* view;
+        nsPoint offset;
+        resultFrame->GetOffsetFromView(offset, &view);
+        ContentOffsets offsets =
+            resultFrame->GetContentOffsetsFromPoint(point - offset);
+        aPos->mResultContent = offsets.content;
+        aPos->mContentOffset = offsets.offset;
+        aPos->mAttach = offsets.associate;
+        if (offsets.content)
+        {
+          bool selectable;
+          resultFrame->IsSelectable(&selectable, nullptr);
+          if (selectable)
+          {
+            found = true;
+            if (resultFrame == farStoppingFrame)
+              aPos->mAttach = CARET_ASSOCIATE_BEFORE;
+            else
+              aPos->mAttach = CARET_ASSOCIATE_AFTER;
+            break;
+          }
+        }
+        if (aPos->mDirection == eDirPrevious && (resultFrame == nearStoppingFrame))
+          break;
+        if (aPos->mDirection == eDirNext && (resultFrame == farStoppingFrame))
+          break;
+        //previous didnt work now we try "next"
+        frameTraversal->Next();
+        nsIFrame *tempFrame = frameTraversal->CurrentItem();
+        if (!tempFrame)
+          break;
+        resultFrame = tempFrame;
+      }
+      aPos->mResultFrame = resultFrame;
+    }
+    else {
+        //we need to jump to new block frame.
+      aPos->mAmount = eSelectLine;
+      aPos->mStartOffset = 0;
+      aPos->mAttach = aPos->mDirection == eDirNext ?
+          CARET_ASSOCIATE_BEFORE : CARET_ASSOCIATE_AFTER;
+      if (aPos->mDirection == eDirPrevious)
+        aPos->mStartOffset = -1;//start from end
+     return aBlockFrame->PeekOffset(aPos);
+    }
+  }
+  return NS_OK;
+}
+
+nsIFrame::CaretPosition
+nsIFrame::GetExtremeCaretPosition(bool aStart)
+{
+  CaretPosition result;
+
+  FrameTarget targetFrame = DrillDownToSelectionFrame(this, !aStart, 0);
+  FrameContentRange range = GetRangeForFrame(targetFrame.frame);
+  result.mResultContent = range.content;
+  result.mContentOffset = aStart ? range.start : range.end;
+  return result;
+}
+
+// Find the first (or last) descendant of the given frame
+// which is either a block frame or a BRFrame.
+static nsContentAndOffset
+FindBlockFrameOrBR(nsIFrame* aFrame, nsDirection aDirection)
+{
+  nsContentAndOffset result;
+  result.mContent =  nullptr;
+  result.mOffset = 0;
+
+  if (aFrame->IsGeneratedContentFrame())
+    return result;
+
+  // Treat form controls as inline leaves
+  // XXX we really need a way to determine whether a frame is inline-level
+  nsIFormControlFrame* fcf = do_QueryFrame(aFrame);
+  if (fcf)
+    return result;
+  
+  // Check the frame itself
+  // Fall through block-in-inline split frames because their mContent is
+  // the content of the inline frames they were created from. The
+  // first/last child of such frames is the real block frame we're
+  // looking for.
+  if ((nsLayoutUtils::GetAsBlock(aFrame) &&
+       !(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) ||
+      aFrame->GetType() == nsGkAtoms::brFrame) {
+    nsIContent* content = aFrame->GetContent();
+    result.mContent = content->GetParent();
+    // In some cases (bug 310589, bug 370174) we end up here with a null content.
+    // This probably shouldn't ever happen, but since it sometimes does, we want
+    // to avoid crashing here.
+    NS_ASSERTION(result.mContent, "Unexpected orphan content");
+    if (result.mContent)
+      result.mOffset = result.mContent->IndexOf(content) + 
+        (aDirection == eDirPrevious ? 1 : 0);
+    return result;
+  }
+
+  // If this is a preformatted text frame, see if it ends with a newline
+  if (aFrame->HasSignificantTerminalNewline()) {
+    int32_t startOffset, endOffset;
+    aFrame->GetOffsets(startOffset, endOffset);
+    result.mContent = aFrame->GetContent();
+    result.mOffset = endOffset - (aDirection == eDirPrevious ? 0 : 1);
+    return result;
+  }
+
+  // Iterate over children and call ourselves recursively
+  if (aDirection == eDirPrevious) {
+    nsIFrame* child = aFrame->GetChildList(nsIFrame::kPrincipalList).LastChild();
+    while(child && !result.mContent) {
+      result = FindBlockFrameOrBR(child, aDirection);
+      child = child->GetPrevSibling();
+    }
+  } else { // eDirNext
+    nsIFrame* child = aFrame->PrincipalChildList().FirstChild();
+    while(child && !result.mContent) {
+      result = FindBlockFrameOrBR(child, aDirection);
+      child = child->GetNextSibling();
+    }
+  }
+  return result;
+}
+
+nsresult
+nsIFrame::PeekOffsetParagraph(nsPeekOffsetStruct *aPos)
+{
+  nsIFrame* frame = this;
+  nsContentAndOffset blockFrameOrBR;
+  blockFrameOrBR.mContent = nullptr;
+  bool reachedBlockAncestor = false;
+
+  // Go through containing frames until reaching a block frame.
+  // In each step, search the previous (or next) siblings for the closest
+  // "stop frame" (a block frame or a BRFrame).
+  // If found, set it to be the selection boundray and abort.
+  
+  if (aPos->mDirection == eDirPrevious) {
+    while (!reachedBlockAncestor) {
+      nsIFrame* parent = frame->GetParent();
+      // Treat a frame associated with the root content as if it were a block frame.
+      if (!frame->mContent || !frame->mContent->GetParent()) {
+        reachedBlockAncestor = true;
+        break;
+      }
+      nsIFrame* sibling = frame->GetPrevSibling();
+      while (sibling && !blockFrameOrBR.mContent) {
+        blockFrameOrBR = FindBlockFrameOrBR(sibling, eDirPrevious);
+        sibling = sibling->GetPrevSibling();
+      }
+      if (blockFrameOrBR.mContent) {
+        aPos->mResultContent = blockFrameOrBR.mContent;
+        aPos->mContentOffset = blockFrameOrBR.mOffset;
+        break;
+      }
+      frame = parent;
+      reachedBlockAncestor = (nsLayoutUtils::GetAsBlock(frame) != nullptr);
+    }
+    if (reachedBlockAncestor) { // no "stop frame" found
+      aPos->mResultContent = frame->GetContent();
+      aPos->mContentOffset = 0;
+    }
+  } else { // eDirNext
+    while (!reachedBlockAncestor) {
+      nsIFrame* parent = frame->GetParent();
+      // Treat a frame associated with the root content as if it were a block frame.
+      if (!frame->mContent || !frame->mContent->GetParent()) {
+        reachedBlockAncestor = true;
+        break;
+      }
+      nsIFrame* sibling = frame;
+      while (sibling && !blockFrameOrBR.mContent) {
+        blockFrameOrBR = FindBlockFrameOrBR(sibling, eDirNext);
+        sibling = sibling->GetNextSibling();
+      }
+      if (blockFrameOrBR.mContent) {
+        aPos->mResultContent = blockFrameOrBR.mContent;
+        aPos->mContentOffset = blockFrameOrBR.mOffset;
+        break;
+      }
+      frame = parent;
+      reachedBlockAncestor = (nsLayoutUtils::GetAsBlock(frame) != nullptr);
+    }
+    if (reachedBlockAncestor) { // no "stop frame" found
+      aPos->mResultContent = frame->GetContent();
+      if (aPos->mResultContent)
+        aPos->mContentOffset = aPos->mResultContent->GetChildCount();
+    }
+  }
+  return NS_OK;
+}
+
+// Determine movement direction relative to frame
+static bool IsMovingInFrameDirection(nsIFrame* frame, nsDirection aDirection, bool aVisual)
+{
+  bool isReverseDirection = aVisual && IsReversedDirectionFrame(frame);
+  return aDirection == (isReverseDirection ? eDirPrevious : eDirNext);
+}
+
+nsresult
+nsIFrame::PeekOffset(nsPeekOffsetStruct* aPos)
+{
+  if (!aPos)
+    return NS_ERROR_NULL_POINTER;
+  nsresult result = NS_ERROR_FAILURE;
+
+  if (mState & NS_FRAME_IS_DIRTY)
+    return NS_ERROR_UNEXPECTED;
+
+  // Translate content offset to be relative to frame
+  FrameContentRange range = GetRangeForFrame(this);
+  int32_t offset = aPos->mStartOffset - range.start;
+  nsIFrame* current = this;
+  
+  switch (aPos->mAmount) {
+    case eSelectCharacter:
+    case eSelectCluster:
+    {
+      bool eatingNonRenderableWS = false;
+      nsIFrame::FrameSearchResult peekSearchState = CONTINUE;
+      bool jumpedLine = false;
+      bool movedOverNonSelectableText = false;
+      
+      while (peekSearchState != FOUND) {
+        bool movingInFrameDirection =
+          IsMovingInFrameDirection(current, aPos->mDirection, aPos->mVisual);
+
+        if (eatingNonRenderableWS)
+          peekSearchState = current->PeekOffsetNoAmount(movingInFrameDirection, &offset); 
+        else
+          peekSearchState = current->PeekOffsetCharacter(movingInFrameDirection, &offset,
+                                              aPos->mAmount == eSelectCluster);
+
+        movedOverNonSelectableText |= (peekSearchState == CONTINUE_UNSELECTABLE);
+
+        if (peekSearchState != FOUND) {
+          bool movedOverNonSelectable = false;
+          result =
+            current->GetFrameFromDirection(aPos->mDirection, aPos->mVisual,
+                                           aPos->mJumpLines, aPos->mScrollViewStop,
+                                           &current, &offset, &jumpedLine,
+                                           &movedOverNonSelectable);
+          if (NS_FAILED(result))
+            return result;
+
+          // If we jumped lines, it's as if we found a character, but we still need
+          // to eat non-renderable content on the new line.
+          if (jumpedLine)
+            eatingNonRenderableWS = true;
+
+          // Remember if we moved over non-selectable text when finding another frame.
+          if (movedOverNonSelectable) {
+            movedOverNonSelectableText = true;
+          }
+        }
+
+        // Found frame, but because we moved over non selectable text we want the offset
+        // to be at the frame edge. Note that if we are extending the selection, this
+        // doesn't matter.
+        if (peekSearchState == FOUND && movedOverNonSelectableText &&
+            !aPos->mExtend)
+        {
+          int32_t start, end;
+          current->GetOffsets(start, end);
+          offset = aPos->mDirection == eDirNext ? 0 : end - start;
+        }
+      }
+
+      // Set outputs
+      range = GetRangeForFrame(current);
+      aPos->mResultFrame = current;
+      aPos->mResultContent = range.content;
+      // Output offset is relative to content, not frame
+      aPos->mContentOffset = offset < 0 ? range.end : range.start + offset;
+      // If we're dealing with a text frame and moving backward positions us at
+      // the end of that line, decrease the offset by one to make sure that
+      // we're placed before the linefeed character on the previous line.
+      if (offset < 0 && jumpedLine &&
+          aPos->mDirection == eDirPrevious &&
+          current->HasSignificantTerminalNewline()) {
+        --aPos->mContentOffset;
+      }
+      
+      break;
+    }
+    case eSelectWordNoSpace:
+      // eSelectWordNoSpace means that we should not be eating any whitespace when
+      // moving to the adjacent word.  This means that we should set aPos->
+      // mWordMovementType to eEndWord if we're moving forwards, and to eStartWord
+      // if we're moving backwards.
+      if (aPos->mDirection == eDirPrevious) {
+        aPos->mWordMovementType = eStartWord;
+      } else {
+        aPos->mWordMovementType = eEndWord;
+      }
+      // Intentionally fall through the eSelectWord case.
+      MOZ_FALLTHROUGH;
+    case eSelectWord:
+    {
+      // wordSelectEatSpace means "are we looking for a boundary between whitespace
+      // and non-whitespace (in the direction we're moving in)".
+      // It is true when moving forward and looking for a beginning of a word, or
+      // when moving backwards and looking for an end of a word.
+      bool wordSelectEatSpace;
+      if (aPos->mWordMovementType != eDefaultBehavior) {
+        // aPos->mWordMovementType possible values:
+        //       eEndWord: eat the space if we're moving backwards
+        //       eStartWord: eat the space if we're moving forwards
+        wordSelectEatSpace = ((aPos->mWordMovementType == eEndWord) == (aPos->mDirection == eDirPrevious));
+      }
+      else {
+        // Use the hidden preference which is based on operating system behavior.
+        // This pref only affects whether moving forward by word should go to the end of this word or start of the next word.
+        // When going backwards, the start of the word is always used, on every operating system.
+        wordSelectEatSpace = aPos->mDirection == eDirNext &&
+          Preferences::GetBool("layout.word_select.eat_space_to_next_word");
+      }
+      
+      // mSawBeforeType means "we already saw characters of the type
+      // before the boundary we're looking for". Examples:
+      // 1. If we're moving forward, looking for a word beginning (i.e. a boundary
+      //    between whitespace and non-whitespace), then eatingWS==true means
+      //    "we already saw some whitespace".
+      // 2. If we're moving backward, looking for a word beginning (i.e. a boundary
+      //    between non-whitespace and whitespace), then eatingWS==true means
+      //    "we already saw some non-whitespace".
+      PeekWordState state;
+      int32_t offsetAdjustment = 0;
+      bool done = false;
+      while (!done) {
+        bool movingInFrameDirection =
+          IsMovingInFrameDirection(current, aPos->mDirection, aPos->mVisual);
+        
+        done = current->PeekOffsetWord(movingInFrameDirection, wordSelectEatSpace,
+                                       aPos->mIsKeyboardSelect, &offset, &state) == FOUND;
+        
+        if (!done) {
+          nsIFrame* nextFrame;
+          int32_t nextFrameOffset;
+          bool jumpedLine, movedOverNonSelectableText;
+          result =
+            current->GetFrameFromDirection(aPos->mDirection, aPos->mVisual,
+                                           aPos->mJumpLines, aPos->mScrollViewStop,
+                                           &nextFrame, &nextFrameOffset, &jumpedLine,
+                                           &movedOverNonSelectableText);
+          // We can't jump lines if we're looking for whitespace following
+          // non-whitespace, and we already encountered non-whitespace.
+          if (NS_FAILED(result) ||
+              (jumpedLine && !wordSelectEatSpace && state.mSawBeforeType)) {
+            done = true;
+            // If we've crossed the line boundary, check to make sure that we
+            // have not consumed a trailing newline as whitesapce if it's significant.
+            if (jumpedLine && wordSelectEatSpace &&
+                current->HasSignificantTerminalNewline()) {
+              offsetAdjustment = -1;
+            }
+          } else {
+            if (jumpedLine) {
+              state.mContext.Truncate();
+            }
+            current = nextFrame;
+            offset = nextFrameOffset;
+            // Jumping a line is equivalent to encountering whitespace
+            if (wordSelectEatSpace && jumpedLine)
+              state.SetSawBeforeType();
+          }
+        }
+      }
+      
+      // Set outputs
+      range = GetRangeForFrame(current);
+      aPos->mResultFrame = current;
+      aPos->mResultContent = range.content;
+      // Output offset is relative to content, not frame
+      aPos->mContentOffset = (offset < 0 ? range.end : range.start + offset) + offsetAdjustment;
+      break;
+    }
+    case eSelectLine :
+    {
+      nsAutoLineIterator iter;
+      nsIFrame *blockFrame = this;
+
+      while (NS_FAILED(result)){
+        int32_t thisLine = nsFrame::GetLineNumber(blockFrame, aPos->mScrollViewStop, &blockFrame);
+        if (thisLine < 0) 
+          return  NS_ERROR_FAILURE;
+        iter = blockFrame->GetLineIterator();
+        NS_ASSERTION(iter, "GetLineNumber() succeeded but no block frame?");
+        result = NS_OK;
+
+        int edgeCase = 0; // no edge case. this should look at thisLine
+        
+        bool doneLooping = false; // tells us when no more block frames hit.
+        // this part will find a frame or a block frame. if it's a block frame
+        // it will "drill down" to find a viable frame or it will return an error.
+        nsIFrame *lastFrame = this;
+        do {
+          result = nsFrame::GetNextPrevLineFromeBlockFrame(PresContext(),
+                                                           aPos, 
+                                                           blockFrame, 
+                                                           thisLine, 
+                                                           edgeCase); // start from thisLine
+
+          // we came back to same spot! keep going
+          if (NS_SUCCEEDED(result) &&
+              (!aPos->mResultFrame || aPos->mResultFrame == lastFrame)) {
+            aPos->mResultFrame = nullptr;
+            if (aPos->mDirection == eDirPrevious)
+              thisLine--;
+            else
+              thisLine++;
+          } else // if failure or success with different frame.
+            doneLooping = true; // do not continue with while loop
+
+          lastFrame = aPos->mResultFrame; // set last frame
+
+          // make sure block element is not the same as the one we had before
+          if (NS_SUCCEEDED(result) &&
+              aPos->mResultFrame &&
+              blockFrame != aPos->mResultFrame) {
+            /* SPECIAL CHECK FOR TABLE NAVIGATION
+               tables need to navigate also and the frame that supports it is
+               nsTableRowGroupFrame which is INSIDE nsTableWrapperFrame.
+               If we have stumbled onto an nsTableWrapperFrame we need to drill
+               into nsTableRowGroup if we hit a header or footer that's ok just
+               go into them.
+             */
+            bool searchTableBool = false;
+            if (aPos->mResultFrame->GetType() == nsGkAtoms::tableWrapperFrame ||
+                aPos->mResultFrame->GetType() == nsGkAtoms::tableCellFrame) {
+              nsIFrame* frame = aPos->mResultFrame->PrincipalChildList().FirstChild();
+              // got the table frame now
+              // ok time to drill down to find iterator
+              while (frame) {
+                iter = frame->GetLineIterator();
+                if (iter) {
+                  aPos->mResultFrame = frame;
+                  searchTableBool = true;
+                  result = NS_OK;
+                  break; // while(frame)
+                }
+                result = NS_ERROR_FAILURE;
+                frame = frame->PrincipalChildList().FirstChild();
+              }
+            }
+
+            if (!searchTableBool) {
+              iter = aPos->mResultFrame->GetLineIterator();
+              result = iter ? NS_OK : NS_ERROR_FAILURE;
+            }
+
+            // we've struck another block element!
+            if (NS_SUCCEEDED(result) && iter) {
+              doneLooping = false;
+              if (aPos->mDirection == eDirPrevious)
+                edgeCase = 1; // far edge, search from end backwards
+              else
+                edgeCase = -1; // near edge search from beginning onwards
+              thisLine = 0; // this line means nothing now.
+              // everything else means something so keep looking "inside" the block
+              blockFrame = aPos->mResultFrame;
+            } else {
+              // THIS is to mean that everything is ok to the containing while loop
+              result = NS_OK;
+              break;
+            }
+          }
+        } while (!doneLooping);
+      }
+      return result;
+    }
+
+    case eSelectParagraph:
+      return PeekOffsetParagraph(aPos);
+
+    case eSelectBeginLine:
+    case eSelectEndLine:
+    {
+      // Adjusted so that the caret can't get confused when content changes
+      nsIFrame* blockFrame = AdjustFrameForSelectionStyles(this);
+      int32_t thisLine = nsFrame::GetLineNumber(blockFrame, aPos->mScrollViewStop, &blockFrame);
+      if (thisLine < 0)
+        return NS_ERROR_FAILURE;
+      nsAutoLineIterator it = blockFrame->GetLineIterator();
+      NS_ASSERTION(it, "GetLineNumber() succeeded but no block frame?");
+
+      int32_t lineFrameCount;
+      nsIFrame *firstFrame;
+      nsRect usedRect;
+      nsIFrame* baseFrame = nullptr;
+      bool endOfLine = (eSelectEndLine == aPos->mAmount);
+
+      if (aPos->mVisual && PresContext()->BidiEnabled()) {
+        bool lineIsRTL = it->GetDirection();
+        bool isReordered;
+        nsIFrame *lastFrame;
+        result = it->CheckLineOrder(thisLine, &isReordered, &firstFrame, &lastFrame);
+        baseFrame = endOfLine ? lastFrame : firstFrame;
+        if (baseFrame) {
+          bool frameIsRTL =
+            (nsBidiPresUtils::FrameDirection(baseFrame) == NSBIDI_RTL);
+          // If the direction of the frame on the edge is opposite to
+          // that of the line, we'll need to drill down to its opposite
+          // end, so reverse endOfLine.
+          if (frameIsRTL != lineIsRTL) {
+            endOfLine = !endOfLine;
+          }
+        }
+      } else {
+        it->GetLine(thisLine, &firstFrame, &lineFrameCount, usedRect);
+
+        nsIFrame* frame = firstFrame;
+        for (int32_t count = lineFrameCount; count;
+             --count, frame = frame->GetNextSibling()) {
+          if (!frame->IsGeneratedContentFrame()) {
+            // When jumping to the end of the line with the "end" key,
+            // skip over brFrames
+            if (endOfLine && lineFrameCount > 1 &&
+                frame->GetType() == nsGkAtoms::brFrame) {
+              continue;
+            }
+            baseFrame = frame;
+            if (!endOfLine)
+              break;
+          }
+        }
+      }
+      if (!baseFrame)
+        return NS_ERROR_FAILURE;
+      FrameTarget targetFrame = DrillDownToSelectionFrame(baseFrame,
+                                                          endOfLine, 0);
+      FrameContentRange range = GetRangeForFrame(targetFrame.frame);
+      aPos->mResultContent = range.content;
+      aPos->mContentOffset = endOfLine ? range.end : range.start;
+      if (endOfLine && targetFrame.frame->HasSignificantTerminalNewline()) {
+        // Do not position the caret after the terminating newline if we're
+        // trying to move to the end of line (see bug 596506)
+        --aPos->mContentOffset;
+      }
+      aPos->mResultFrame = targetFrame.frame;
+      aPos->mAttach = aPos->mContentOffset == range.start ?
+          CARET_ASSOCIATE_AFTER : CARET_ASSOCIATE_BEFORE;
+      if (!range.content)
+        return NS_ERROR_FAILURE;
+      return NS_OK;
+    }
+
+    default: 
+    {
+      NS_ASSERTION(false, "Invalid amount");
+      return NS_ERROR_FAILURE;
+    }
+  }
+  return NS_OK;
+}
+
+nsIFrame::FrameSearchResult
+nsFrame::PeekOffsetNoAmount(bool aForward, int32_t* aOffset)
+{
+  NS_ASSERTION (aOffset && *aOffset <= 1, "aOffset out of range");
+  // Sure, we can stop right here.
+  return FOUND;
+}
+
+nsIFrame::FrameSearchResult
+nsFrame::PeekOffsetCharacter(bool aForward, int32_t* aOffset,
+                             bool aRespectClusters)
+{
+  NS_ASSERTION (aOffset && *aOffset <= 1, "aOffset out of range");
+  int32_t startOffset = *aOffset;
+  // A negative offset means "end of frame", which in our case means offset 1.
+  if (startOffset < 0)
+    startOffset = 1;
+  if (aForward == (startOffset == 0)) {
+    // We're before the frame and moving forward, or after it and moving backwards:
+    // skip to the other side and we're done.
+    *aOffset = 1 - startOffset;
+    return FOUND;
+  }
+  return CONTINUE;
+}
+
+nsIFrame::FrameSearchResult
+nsFrame::PeekOffsetWord(bool            aForward,
+                        bool            aWordSelectEatSpace,
+                        bool            aIsKeyboardSelect,
+                        int32_t*        aOffset,
+                        PeekWordState*  aState)
+{
+  NS_ASSERTION (aOffset && *aOffset <= 1, "aOffset out of range");
+  int32_t startOffset = *aOffset;
+  // This isn't text, so truncate the context
+  aState->mContext.Truncate();
+  if (startOffset < 0)
+    startOffset = 1;
+  if (aForward == (startOffset == 0)) {
+    // We're before the frame and moving forward, or after it and moving backwards.
+    // If we're looking for non-whitespace, we found it (without skipping this frame).
+    if (!aState->mAtStart) {
+      if (aState->mLastCharWasPunctuation) {
+        // We're not punctuation, so this is a punctuation boundary.
+        if (BreakWordBetweenPunctuation(aState, aForward, false, false, aIsKeyboardSelect))
+          return FOUND;
+      } else {
+        // This is not a punctuation boundary.
+        if (aWordSelectEatSpace && aState->mSawBeforeType)
+          return FOUND;
+      }
+    }
+    // Otherwise skip to the other side and note that we encountered non-whitespace.
+    *aOffset = 1 - startOffset;
+    aState->Update(false, // not punctuation
+                   false     // not whitespace
+                   );
+    if (!aWordSelectEatSpace)
+      aState->SetSawBeforeType();
+  }
+  return CONTINUE;
+}
+
+bool
+nsFrame::BreakWordBetweenPunctuation(const PeekWordState* aState,
+                                     bool aForward,
+                                     bool aPunctAfter, bool aWhitespaceAfter,
+                                     bool aIsKeyboardSelect)
+{
+  NS_ASSERTION(aPunctAfter != aState->mLastCharWasPunctuation,
+               "Call this only at punctuation boundaries");
+  if (aState->mLastCharWasWhitespace) {
+    // We always stop between whitespace and punctuation
+    return true;
+  }
+  if (!Preferences::GetBool("layout.word_select.stop_at_punctuation")) {
+    // When this pref is false, we never stop at a punctuation boundary unless
+    // it's followed by whitespace (in the relevant direction).
+    return aWhitespaceAfter;
+  }
+  if (!aIsKeyboardSelect) {
+    // mouse caret movement (e.g. word selection) always stops at every punctuation boundary
+    return true;
+  }
+  bool afterPunct = aForward ? aState->mLastCharWasPunctuation : aPunctAfter;
+  if (!afterPunct) {
+    // keyboard caret movement only stops after punctuation (in content order)
+    return false;
+  }
+  // Stop only if we've seen some non-punctuation since the last whitespace;
+  // don't stop after punctuation that follows whitespace.
+  return aState->mSeenNonPunctuationSinceWhitespace;
+}
+
+nsresult
+nsFrame::CheckVisibility(nsPresContext* , int32_t , int32_t , bool , bool *, bool *)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+int32_t
+nsFrame::GetLineNumber(nsIFrame *aFrame, bool aLockScroll, nsIFrame** aContainingBlock)
+{
+  NS_ASSERTION(aFrame, "null aFrame");
+  nsFrameManager* frameManager = aFrame->PresContext()->FrameManager();
+  nsIFrame *blockFrame = aFrame;
+  nsIFrame *thisBlock;
+  nsAutoLineIterator it;
+  nsresult result = NS_ERROR_FAILURE;
+  while (NS_FAILED(result) && blockFrame)
+  {
+    thisBlock = blockFrame;
+    if (thisBlock->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
+      //if we are searching for a frame that is not in flow we will not find it. 
+      //we must instead look for its placeholder
+      if (thisBlock->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER) {
+        // abspos continuations don't have placeholders, get the fif
+        thisBlock = thisBlock->FirstInFlow();
+      }
+      thisBlock = frameManager->GetPlaceholderFrameFor(thisBlock);
+      if (!thisBlock)
+        return -1;
+    }  
+    blockFrame = thisBlock->GetParent();
+    result = NS_OK;
+    if (blockFrame) {
+      if (aLockScroll && blockFrame->GetType() == nsGkAtoms::scrollFrame)
+        return -1;
+      it = blockFrame->GetLineIterator();
+      if (!it)
+        result = NS_ERROR_FAILURE;
+    }
+  }
+  if (!blockFrame || !it)
+    return -1;
+
+  if (aContainingBlock)
+    *aContainingBlock = blockFrame;
+  return it->FindLineContaining(thisBlock);
+}
+
+nsresult
+nsIFrame::GetFrameFromDirection(nsDirection aDirection, bool aVisual,
+                                bool aJumpLines, bool aScrollViewStop,
+                                nsIFrame** aOutFrame, int32_t* aOutOffset,
+                                bool* aOutJumpedLine, bool* aOutMovedOverNonSelectableText)
+{
+  nsresult result;
+
+  if (!aOutFrame || !aOutOffset || !aOutJumpedLine)
+    return NS_ERROR_NULL_POINTER;
+  
+  nsPresContext* presContext = PresContext();
+  *aOutFrame = nullptr;
+  *aOutOffset = 0;
+  *aOutJumpedLine = false;
+  *aOutMovedOverNonSelectableText = false;
+
+  // Find the prev/next selectable frame
+  bool selectable = false;
+  nsIFrame *traversedFrame = this;
+  while (!selectable) {
+    nsIFrame *blockFrame;
+    
+    int32_t thisLine = nsFrame::GetLineNumber(traversedFrame, aScrollViewStop, &blockFrame);
+    if (thisLine < 0)
+      return NS_ERROR_FAILURE;
+
+    nsAutoLineIterator it = blockFrame->GetLineIterator();
+    NS_ASSERTION(it, "GetLineNumber() succeeded but no block frame?");
+
+    bool atLineEdge;
+    nsIFrame *firstFrame;
+    nsIFrame *lastFrame;
+    if (aVisual && presContext->BidiEnabled()) {
+      bool lineIsRTL = it->GetDirection();
+      bool isReordered;
+      result = it->CheckLineOrder(thisLine, &isReordered, &firstFrame, &lastFrame);
+      nsIFrame** framePtr = aDirection == eDirPrevious ? &firstFrame : &lastFrame;
+      if (*framePtr) {
+        bool frameIsRTL =
+          (nsBidiPresUtils::FrameDirection(*framePtr) == NSBIDI_RTL);
+        if ((frameIsRTL == lineIsRTL) == (aDirection == eDirPrevious)) {
+          nsFrame::GetFirstLeaf(presContext, framePtr);
+        } else {
+          nsFrame::GetLastLeaf(presContext, framePtr);
+        }
+        atLineEdge = *framePtr == traversedFrame;
+      } else {
+        atLineEdge = true;
+      }
+    } else {
+      nsRect  nonUsedRect;
+      int32_t lineFrameCount;
+      result = it->GetLine(thisLine, &firstFrame, &lineFrameCount,
+                           nonUsedRect);
+      if (NS_FAILED(result))
+        return result;
+
+      if (aDirection == eDirPrevious) {
+        nsFrame::GetFirstLeaf(presContext, &firstFrame);
+        atLineEdge = firstFrame == traversedFrame;
+      } else { // eDirNext
+        lastFrame = firstFrame;
+        for (;lineFrameCount > 1;lineFrameCount --){
+          result = it->GetNextSiblingOnLine(lastFrame, thisLine);
+          if (NS_FAILED(result) || !lastFrame){
+            NS_ERROR("should not be reached nsFrame");
+            return NS_ERROR_FAILURE;
+          }
+        }
+        nsFrame::GetLastLeaf(presContext, &lastFrame);
+        atLineEdge = lastFrame == traversedFrame;
+      }
+    }
+
+    if (atLineEdge) {
+      *aOutJumpedLine = true;
+      if (!aJumpLines)
+        return NS_ERROR_FAILURE; //we are done. cannot jump lines
+    }
+
+    nsCOMPtr<nsIFrameEnumerator> frameTraversal;
+    result = NS_NewFrameTraversal(getter_AddRefs(frameTraversal),
+                                  presContext, traversedFrame,
+                                  eLeaf,
+                                  aVisual && presContext->BidiEnabled(),
+                                  aScrollViewStop,
+                                  true,  // aFollowOOFs
+                                  false  // aSkipPopupChecks
+                                  );
+    if (NS_FAILED(result))
+      return result;
+
+    if (aDirection == eDirNext)
+      frameTraversal->Next();
+    else
+      frameTraversal->Prev();
+
+    traversedFrame = frameTraversal->CurrentItem();
+
+    // Skip anonymous elements, but watch out for generated content
+    if (!traversedFrame ||
+        (!traversedFrame->IsGeneratedContentFrame() &&
+         traversedFrame->GetContent()->IsRootOfNativeAnonymousSubtree())) {
+      return NS_ERROR_FAILURE;
+    }
+
+    // Skip brFrames, but only if they are not the only frame in the line
+    if (atLineEdge && aDirection == eDirPrevious &&
+        traversedFrame->GetType() == nsGkAtoms::brFrame) {
+      int32_t lineFrameCount;
+      nsIFrame *currentBlockFrame, *currentFirstFrame;
+      nsRect usedRect;
+      int32_t currentLine = nsFrame::GetLineNumber(traversedFrame, aScrollViewStop, &currentBlockFrame);
+      nsAutoLineIterator iter = currentBlockFrame->GetLineIterator();
+      result = iter->GetLine(currentLine, &currentFirstFrame, &lineFrameCount, usedRect);
+      if (NS_FAILED(result)) {
+        return result;
+      }
+      if (lineFrameCount > 1) {
+        continue;
+      }
+    }
+
+    traversedFrame->IsSelectable(&selectable, nullptr);
+    if (!selectable) {
+      *aOutMovedOverNonSelectableText = true;
+    }
+  } // while (!selectable)
+
+  *aOutOffset = (aDirection == eDirNext) ? 0 : -1;
+
+  if (aVisual && IsReversedDirectionFrame(traversedFrame)) {
+    // The new frame is reverse-direction, go to the other end
+    *aOutOffset = -1 - *aOutOffset;
+  }
+  *aOutFrame = traversedFrame;
+  return NS_OK;
+}
+
+nsView* nsIFrame::GetClosestView(nsPoint* aOffset) const
+{
+  nsPoint offset(0,0);
+  for (const nsIFrame *f = this; f; f = f->GetParent()) {
+    if (f->HasView()) {
+      if (aOffset)
+        *aOffset = offset;
+      return f->GetView();
+    }
+    offset += f->GetPosition();
+  }
+
+  NS_NOTREACHED("No view on any parent?  How did that happen?");
+  return nullptr;
+}
+
+
+/* virtual */ void
+nsFrame::ChildIsDirty(nsIFrame* aChild)
+{
+  NS_NOTREACHED("should never be called on a frame that doesn't inherit from "
+                "nsContainerFrame");
+}
+
+
+#ifdef ACCESSIBILITY
+a11y::AccType
+nsFrame::AccessibleType()
+{
+  if (IsTableCaption() && !GetRect().IsEmpty()) {
+    return a11y::eHTMLCaptionType;
+  }
+  return a11y::eNoType;
+}
+#endif
+
+NS_DECLARE_FRAME_PROPERTY_DELETABLE(OverflowAreasProperty, nsOverflowAreas)
+
+bool
+nsIFrame::ClearOverflowRects()
+{
+  if (mOverflow.mType == NS_FRAME_OVERFLOW_NONE) {
+    return false;
+  }
+  if (mOverflow.mType == NS_FRAME_OVERFLOW_LARGE) {
+    Properties().Delete(OverflowAreasProperty());
+  }
+  mOverflow.mType = NS_FRAME_OVERFLOW_NONE;
+  return true;
+}
+
+/** Create or retrieve the previously stored overflow area, if the frame does 
+ * not overflow and no creation is required return nullptr.
+ * @return pointer to the overflow area rectangle 
+ */
+nsOverflowAreas*
+nsIFrame::GetOverflowAreasProperty()
+{
+  FrameProperties props = Properties();
+  nsOverflowAreas* overflow = props.Get(OverflowAreasProperty());
+
+  if (overflow) {
+    return overflow; // the property already exists
+  }
+
+  // The property isn't set yet, so allocate a new rect, set the property,
+  // and return the newly allocated rect
+  overflow = new nsOverflowAreas;
+  props.Set(OverflowAreasProperty(), overflow);
+  return overflow;
+}
+
+/** Set the overflowArea rect, storing it as deltas or a separate rect
+ * depending on its size in relation to the primary frame rect.
+ */
+bool
+nsIFrame::SetOverflowAreas(const nsOverflowAreas& aOverflowAreas)
+{
+  if (mOverflow.mType == NS_FRAME_OVERFLOW_LARGE) {
+    nsOverflowAreas* overflow = Properties().Get(OverflowAreasProperty());
+    bool changed = *overflow != aOverflowAreas;
+    *overflow = aOverflowAreas;
+
+    // Don't bother with converting to the deltas form if we already
+    // have a property.
+    return changed;
+  }
+
+  const nsRect& vis = aOverflowAreas.VisualOverflow();
+  uint32_t l = -vis.x, // left edge: positive delta is leftwards
+           t = -vis.y, // top: positive is upwards
+           r = vis.XMost() - mRect.width, // right: positive is rightwards
+           b = vis.YMost() - mRect.height; // bottom: positive is downwards
+  if (aOverflowAreas.ScrollableOverflow().IsEqualEdges(nsRect(nsPoint(0, 0), GetSize())) &&
+      l <= NS_FRAME_OVERFLOW_DELTA_MAX &&
+      t <= NS_FRAME_OVERFLOW_DELTA_MAX &&
+      r <= NS_FRAME_OVERFLOW_DELTA_MAX &&
+      b <= NS_FRAME_OVERFLOW_DELTA_MAX &&
+      // we have to check these against zero because we *never* want to
+      // set a frame as having no overflow in this function.  This is
+      // because FinishAndStoreOverflow calls this function prior to
+      // SetRect based on whether the overflow areas match aNewSize.
+      // In the case where the overflow areas exactly match mRect but
+      // do not match aNewSize, we need to store overflow in a property
+      // so that our eventual SetRect/SetSize will know that it has to
+      // reset our overflow areas.
+      (l | t | r | b) != 0) {
+    VisualDeltas oldDeltas = mOverflow.mVisualDeltas;
+    // It's a "small" overflow area so we store the deltas for each edge
+    // directly in the frame, rather than allocating a separate rect.
+    // If they're all zero, that's fine; we're setting things to
+    // no-overflow.
+    mOverflow.mVisualDeltas.mLeft   = l;
+    mOverflow.mVisualDeltas.mTop    = t;
+    mOverflow.mVisualDeltas.mRight  = r;
+    mOverflow.mVisualDeltas.mBottom = b;
+    // There was no scrollable overflow before, and there isn't now.
+    return oldDeltas != mOverflow.mVisualDeltas;
+  } else {
+    bool changed = !aOverflowAreas.ScrollableOverflow().IsEqualEdges(nsRect(nsPoint(0, 0), GetSize())) ||
+      !aOverflowAreas.VisualOverflow().IsEqualEdges(GetVisualOverflowFromDeltas());
+
+    // it's a large overflow area that we need to store as a property
+    mOverflow.mType = NS_FRAME_OVERFLOW_LARGE;
+    nsOverflowAreas* overflow = GetOverflowAreasProperty();
+    NS_ASSERTION(overflow, "should have created areas");
+    *overflow = aOverflowAreas;
+    return changed;
+  }
+}
+
+inline bool
+IsInlineFrame(nsIFrame *aFrame)
+{
+  nsIAtom *type = aFrame->GetType();
+  return type == nsGkAtoms::inlineFrame;
+}
+
+/**
+ * Compute the union of the border boxes of aFrame and its descendants,
+ * in aFrame's coordinate space (if aApplyTransform is false) or its
+ * post-transform coordinate space (if aApplyTransform is true).
+ */
+static nsRect
+UnionBorderBoxes(nsIFrame* aFrame, bool aApplyTransform,
+                 bool& aOutValid,
+                 const nsSize* aSizeOverride = nullptr,
+                 const nsOverflowAreas* aOverflowOverride = nullptr)
+{
+  const nsRect bounds(nsPoint(0, 0),
+                      aSizeOverride ? *aSizeOverride : aFrame->GetSize());
+
+  // The SVG container frames do not maintain an accurate mRect.
+  // It will make the outline be larger than we expect, we need
+  // to make them narrow to their children's outline.
+  // aOutValid is set to false if the returned nsRect is not valid
+  // and should not be included in the outline rectangle.
+  aOutValid = !aFrame->IsFrameOfType(nsIFrame::eSVGContainer);
+
+  // Start from our border-box, transformed.  See comment below about
+  // transform of children.
+  nsRect u;
+  bool doTransform = aApplyTransform && aFrame->IsTransformed();
+  if (doTransform) {
+    u = nsDisplayTransform::TransformRect(bounds, aFrame, &bounds);
+  } else {
+    u = bounds;
+  }
+
+  // Only iterate through the children if the overflow areas suggest
+  // that we might need to, and if the frame doesn't clip its overflow
+  // anyway.
+  if (aOverflowOverride) {
+    if (!doTransform &&
+        bounds.IsEqualEdges(aOverflowOverride->VisualOverflow()) &&
+        bounds.IsEqualEdges(aOverflowOverride->ScrollableOverflow())) {
+      return u;
+    }
+  } else {
+    if (!doTransform &&
+        bounds.IsEqualEdges(aFrame->GetVisualOverflowRect()) &&
+        bounds.IsEqualEdges(aFrame->GetScrollableOverflowRect())) {
+      return u;
+    }
+  }
+  const nsStyleDisplay* disp = aFrame->StyleDisplay();
+  nsIAtom* fType = aFrame->GetType();
+  if (nsFrame::ShouldApplyOverflowClipping(aFrame, disp) ||
+      fType == nsGkAtoms::scrollFrame ||
+      fType == nsGkAtoms::listControlFrame ||
+      fType == nsGkAtoms::svgOuterSVGFrame) {
+    return u;
+  }
+
+  const nsStyleEffects* effects = aFrame->StyleEffects();
+  Maybe<nsRect> clipPropClipRect =
+    aFrame->GetClipPropClipRect(disp, effects, bounds.Size());
+
+  // Iterate over all children except pop-ups.
+  const nsIFrame::ChildListIDs skip(nsIFrame::kPopupList |
+                                    nsIFrame::kSelectPopupList);
+  for (nsIFrame::ChildListIterator childLists(aFrame);
+       !childLists.IsDone(); childLists.Next()) {
+    if (skip.Contains(childLists.CurrentID())) {
+      continue;
+    }
+
+    nsFrameList children = childLists.CurrentList();
+    for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
+      nsIFrame* child = e.get();
+      // Note that passing |true| for aApplyTransform when
+      // child->Combines3DTransformWithAncestors() is incorrect if our
+      // aApplyTransform is false... but the opposite would be as
+      // well.  This is because elements within a preserve-3d scene
+      // are always transformed up to the top of the scene.  This
+      // means we don't have a mechanism for getting a transform up to
+      // an intermediate point within the scene.  We choose to
+      // over-transform rather than under-transform because this is
+      // consistent with other overflow areas.
+      bool validRect = true;
+      nsRect childRect = UnionBorderBoxes(child, true, validRect) +
+                         child->GetPosition();
+
+      if (!validRect) {
+        continue;
+      }
+
+      if (clipPropClipRect) {
+        // Intersect with the clip before transforming.
+        childRect.IntersectRect(childRect, *clipPropClipRect);
+      }
+
+      // Note that we transform each child separately according to
+      // aFrame's transform, and then union, which gives a different
+      // (smaller) result from unioning and then transforming the
+      // union.  This doesn't match the way we handle overflow areas
+      // with 2-D transforms, though it does match the way we handle
+      // overflow areas in preserve-3d 3-D scenes.
+      if (doTransform && !child->Combines3DTransformWithAncestors()) {
+        childRect = nsDisplayTransform::TransformRect(childRect, aFrame, &bounds);
+      }
+
+      // If a SVGContainer has a non-SVGContainer child, we assign
+      // its child's outline to this SVGContainer directly.
+      if (!aOutValid && validRect) {
+        u = childRect;
+        aOutValid = true;
+      } else {
+        u.UnionRectEdges(u, childRect);
+      }
+    }
+  }
+
+  return u;
+}
+
+static void
+ComputeAndIncludeOutlineArea(nsIFrame* aFrame, nsOverflowAreas& aOverflowAreas,
+                             const nsSize& aNewSize)
+{
+  const nsStyleOutline* outline = aFrame->StyleOutline();
+  const uint8_t outlineStyle = outline->mOutlineStyle;
+  if (outlineStyle == NS_STYLE_BORDER_STYLE_NONE) {
+    return;
+  }
+
+  nscoord width = outline->GetOutlineWidth();
+  if (width <= 0 && outlineStyle != NS_STYLE_BORDER_STYLE_AUTO) {
+    return;
+  }
+
+  // When the outline property is set on :-moz-anonymous-block or
+  // :-moz-anonymous-positioned-block pseudo-elements, it inherited
+  // that outline from the inline that was broken because it
+  // contained a block.  In that case, we don't want a really wide
+  // outline if the block inside the inline is narrow, so union the
+  // actual contents of the anonymous blocks.
+  nsIFrame *frameForArea = aFrame;
+  do {
+    nsIAtom *pseudoType = frameForArea->StyleContext()->GetPseudo();
+    if (pseudoType != nsCSSAnonBoxes::mozAnonymousBlock &&
+        pseudoType != nsCSSAnonBoxes::mozAnonymousPositionedBlock)
+      break;
+    // If we're done, we really want it and all its later siblings.
+    frameForArea = frameForArea->PrincipalChildList().FirstChild();
+    NS_ASSERTION(frameForArea, "anonymous block with no children?");
+  } while (frameForArea);
+
+  // Find the union of the border boxes of all descendants, or in
+  // the block-in-inline case, all descendants we care about.
+  //
+  // Note that the interesting perspective-related cases are taken
+  // care of by the code that handles those issues for overflow
+  // calling FinishAndStoreOverflow again, which in turn calls this
+  // function again.  We still need to deal with preserve-3d a bit.
+  nsRect innerRect;
+  bool validRect;
+  if (frameForArea == aFrame) {
+    innerRect = UnionBorderBoxes(aFrame, false, validRect, &aNewSize, &aOverflowAreas);
+  } else {
+    for (; frameForArea; frameForArea = frameForArea->GetNextSibling()) {
+      nsRect r(UnionBorderBoxes(frameForArea, true, validRect));
+
+      // Adjust for offsets transforms up to aFrame's pre-transform
+      // (i.e., normal) coordinate space; see comments in
+      // UnionBorderBoxes for some of the subtlety here.
+      for (nsIFrame *f = frameForArea, *parent = f->GetParent();
+           /* see middle of loop */;
+           f = parent, parent = f->GetParent()) {
+        r += f->GetPosition();
+        if (parent == aFrame) {
+          break;
+        }
+        if (parent->IsTransformed() && !f->Combines3DTransformWithAncestors()) {
+          r = nsDisplayTransform::TransformRect(r, parent);
+        }
+      }
+
+      innerRect.UnionRect(innerRect, r);
+    }
+  }
+
+  // Keep this code in sync with GetOutlineInnerRect in nsCSSRendering.cpp.
+  aFrame->Properties().Set(nsIFrame::OutlineInnerRectProperty(),
+                           new nsRect(innerRect));
+  const nscoord offset = outline->mOutlineOffset;
+  nsRect outerRect(innerRect);
+  bool useOutlineAuto = false;
+  if (nsLayoutUtils::IsOutlineStyleAutoEnabled()) {
+    useOutlineAuto = outlineStyle == NS_STYLE_BORDER_STYLE_AUTO;
+    if (MOZ_UNLIKELY(useOutlineAuto)) {
+      nsPresContext* presContext = aFrame->PresContext();
+      nsITheme* theme = presContext->GetTheme();
+      if (theme && theme->ThemeSupportsWidget(presContext, aFrame,
+                                              NS_THEME_FOCUS_OUTLINE)) {
+        outerRect.Inflate(offset);
+        theme->GetWidgetOverflow(presContext->DeviceContext(), aFrame,
+                                 NS_THEME_FOCUS_OUTLINE, &outerRect);
+      } else {
+        useOutlineAuto = false;
+      }
+    }
+  }
+  if (MOZ_LIKELY(!useOutlineAuto)) {
+    outerRect.Inflate(width + offset);
+  }
+
+  nsRect& vo = aOverflowAreas.VisualOverflow();
+  vo.UnionRectEdges(vo, innerRect.Union(outerRect));
+}
+
+bool
+nsIFrame::FinishAndStoreOverflow(nsOverflowAreas& aOverflowAreas,
+                                 nsSize aNewSize, nsSize* aOldSize)
+{
+  NS_ASSERTION(FrameMaintainsOverflow(),
+               "Don't call - overflow rects not maintained on these SVG frames");
+
+  nsRect bounds(nsPoint(0, 0), aNewSize);
+  // Store the passed in overflow area if we are a preserve-3d frame or we have
+  // a transform, and it's not just the frame bounds.
+  if (Combines3DTransformWithAncestors() || IsTransformed()) {
+    if (!aOverflowAreas.VisualOverflow().IsEqualEdges(bounds) ||
+        !aOverflowAreas.ScrollableOverflow().IsEqualEdges(bounds)) {
+      nsOverflowAreas* initial =
+        Properties().Get(nsIFrame::InitialOverflowProperty());
+      if (!initial) {
+        Properties().Set(nsIFrame::InitialOverflowProperty(),
+                         new nsOverflowAreas(aOverflowAreas));
+      } else if (initial != &aOverflowAreas) {
+        *initial = aOverflowAreas;
+      }
+    } else {
+      Properties().Delete(nsIFrame::InitialOverflowProperty());
+    }
+#ifdef DEBUG
+    Properties().Set(nsIFrame::DebugInitialOverflowPropertyApplied(), true);
+#endif
+  } else {
+#ifdef DEBUG
+    Properties().Delete(nsIFrame::DebugInitialOverflowPropertyApplied());
+#endif
+  }
+
+  // This is now called FinishAndStoreOverflow() instead of 
+  // StoreOverflow() because frame-generic ways of adding overflow
+  // can happen here, e.g. CSS2 outline and native theme.
+  // If the overflow area width or height is nscoord_MAX, then a
+  // saturating union may have encounted an overflow, so the overflow may not
+  // contain the frame border-box. Don't warn in that case.
+  // Don't warn for SVG either, since SVG doesn't need the overflow area
+  // to contain the frame bounds.
+  NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
+    DebugOnly<nsRect*> r = &aOverflowAreas.Overflow(otype);
+    NS_ASSERTION(aNewSize.width == 0 || aNewSize.height == 0 ||
+                 r->width == nscoord_MAX || r->height == nscoord_MAX ||
+                 (mState & NS_FRAME_SVG_LAYOUT) ||
+                 r->Contains(nsRect(nsPoint(0,0), aNewSize)),
+                 "Computed overflow area must contain frame bounds");
+  }
+
+  // If we clip our children, clear accumulated overflow area. The
+  // children are actually clipped to the padding-box, but since the
+  // overflow area should include the entire border-box, just set it to
+  // the border-box here.
+  const nsStyleDisplay* disp = StyleDisplay();
+  NS_ASSERTION((disp->mOverflowY == NS_STYLE_OVERFLOW_CLIP) ==
+               (disp->mOverflowX == NS_STYLE_OVERFLOW_CLIP),
+               "If one overflow is clip, the other should be too");
+  if (nsFrame::ShouldApplyOverflowClipping(this, disp)) {
+    // The contents are actually clipped to the padding area 
+    aOverflowAreas.SetAllTo(bounds);
+  }
+
+  // Overflow area must always include the frame's top-left and bottom-right,
+  // even if the frame rect is empty (so we can scroll to those positions).
+  // Pending a real fix for bug 426879, don't do this for inline frames
+  // with zero width.
+  // Do not do this for SVG either, since it will usually massively increase
+  // the area unnecessarily.
+  if ((aNewSize.width != 0 || !IsInlineFrame(this)) &&
+      !(GetStateBits() & NS_FRAME_SVG_LAYOUT)) {
+    NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
+      nsRect& o = aOverflowAreas.Overflow(otype);
+      o.UnionRectEdges(o, bounds);
+    }
+  }
+
+  // Note that NS_STYLE_OVERFLOW_CLIP doesn't clip the frame background,
+  // so we add theme background overflow here so it's not clipped.
+  if (!::IsXULBoxWrapped(this) && IsThemed(disp)) {
+    nsRect r(bounds);
+    nsPresContext *presContext = PresContext();
+    if (presContext->GetTheme()->
+          GetWidgetOverflow(presContext->DeviceContext(), this,
+                            disp->mAppearance, &r)) {
+      nsRect& vo = aOverflowAreas.VisualOverflow();
+      vo.UnionRectEdges(vo, r);
+    }
+  }
+
+  ComputeAndIncludeOutlineArea(this, aOverflowAreas, aNewSize);
+
+  // Nothing in here should affect scrollable overflow.
+  aOverflowAreas.VisualOverflow() =
+    ComputeEffectsRect(this, aOverflowAreas.VisualOverflow(), aNewSize);
+
+  // Absolute position clipping
+  const nsStyleEffects* effects = StyleEffects();
+  Maybe<nsRect> clipPropClipRect =
+    GetClipPropClipRect(disp, effects, aNewSize);
+  if (clipPropClipRect) {
+    NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
+      nsRect& o = aOverflowAreas.Overflow(otype);
+      o.IntersectRect(o, *clipPropClipRect);
+    }
+  }
+
+  /* If we're transformed, transform the overflow rect by the current transformation. */
+  bool hasTransform = IsTransformed();
+  nsSize oldSize = mRect.Size();
+  bool sizeChanged = ((aOldSize ? *aOldSize : oldSize) != aNewSize);
+
+  /* Since our size might not actually have been computed yet, we need to make sure that we use the
+   * correct dimensions by overriding the stored bounding rectangle with the value the caller has
+   * ensured us we'll use.
+   */
+  SetSize(aNewSize);
+
+  if (ChildrenHavePerspective() && sizeChanged) {
+    nsRect newBounds(nsPoint(0, 0), aNewSize);
+    RecomputePerspectiveChildrenOverflow(this);
+  }
+
+  if (hasTransform) {
+    Properties().Set(nsIFrame::PreTransformOverflowAreasProperty(),
+                     new nsOverflowAreas(aOverflowAreas));
+
+    if (Combines3DTransformWithAncestors()) {
+      /* If we're a preserve-3d leaf frame, then our pre-transform overflow should be correct. Our
+       * post-transform overflow is empty though, because we only contribute to the overflow area
+       * of the preserve-3d root frame.
+       * If we're an intermediate frame then the pre-transform overflow should contain all our
+       * non-preserve-3d children, which is what we want. Again we have no post-transform overflow.
+       */
+      aOverflowAreas.SetAllTo(nsRect());
+    } else {
+      NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
+        nsRect& o = aOverflowAreas.Overflow(otype);
+        o = nsDisplayTransform::TransformRect(o, this);
+      }
+
+      /* If we're the root of the 3d context, then we want to include the overflow areas of all
+       * the participants. This won't have happened yet as the code above set their overflow
+       * area to empty. Manually collect these overflow areas now.
+       */
+      if (Extend3DContext()) {
+        ComputePreserve3DChildrenOverflow(aOverflowAreas);
+      }
+    }
+  } else {
+    Properties().Delete(nsIFrame::PreTransformOverflowAreasProperty());
+  }
+
+  /* Revert the size change in case some caller is depending on this. */
+  SetSize(oldSize);
+
+  bool anyOverflowChanged;
+  if (aOverflowAreas != nsOverflowAreas(bounds, bounds)) {
+    anyOverflowChanged = SetOverflowAreas(aOverflowAreas);
+  } else {
+    anyOverflowChanged = ClearOverflowRects();
+  }
+
+  if (anyOverflowChanged) {
+    nsSVGEffects::InvalidateDirectRenderingObservers(this);
+  }
+  return anyOverflowChanged;
+}
+
+void
+nsIFrame::RecomputePerspectiveChildrenOverflow(const nsIFrame* aStartFrame)
+{
+  nsIFrame::ChildListIterator lists(this);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      nsIFrame* child = childFrames.get();
+      if (!child->FrameMaintainsOverflow()) {
+        continue; // frame does not maintain overflow rects
+      }
+      if (child->HasPerspective()) {
+        nsOverflowAreas* overflow = 
+          child->Properties().Get(nsIFrame::InitialOverflowProperty());
+        nsRect bounds(nsPoint(0, 0), child->GetSize());
+        if (overflow) {
+          nsOverflowAreas overflowCopy = *overflow;
+          child->FinishAndStoreOverflow(overflowCopy, bounds.Size());
+        } else {
+          nsOverflowAreas boundsOverflow;
+          boundsOverflow.SetAllTo(bounds);
+          child->FinishAndStoreOverflow(boundsOverflow, bounds.Size());
+        }
+      } else if (child->GetContainingBlock(SKIP_SCROLLED_FRAME) == aStartFrame) {
+        // If a frame is using perspective, then the size used to compute
+        // perspective-origin is the size of the frame belonging to its parent
+        // style context. We must find any descendant frames using our size
+        // (by recursing into frames that have the same containing block)
+        // to update their overflow rects too.
+        child->RecomputePerspectiveChildrenOverflow(aStartFrame);
+      }
+    }
+  }
+}
+
+void
+nsIFrame::ComputePreserve3DChildrenOverflow(nsOverflowAreas& aOverflowAreas)
+{
+  // Find all descendants that participate in the 3d context, and include their overflow.
+  // These descendants have an empty overflow, so won't have been included in the normal
+  // overflow calculation. Any children that don't participate have normal overflow,
+  // so will have been included already.
+
+  nsRect childVisual;
+  nsRect childScrollable;
+  nsIFrame::ChildListIterator lists(this);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      nsIFrame* child = childFrames.get();
+
+      // If this child participates in the 3d context, then take the pre-transform
+      // region (which contains all descendants that aren't participating in the 3d context)
+      // and transform it into the 3d context root coordinate space.
+      if (child->Combines3DTransformWithAncestors()) {
+        nsOverflowAreas childOverflow = child->GetOverflowAreasRelativeToSelf();
+
+        NS_FOR_FRAME_OVERFLOW_TYPES(otype) {
+          nsRect& o = childOverflow.Overflow(otype);
+          o = nsDisplayTransform::TransformRect(o, child);
+        }
+
+        aOverflowAreas.UnionWith(childOverflow);
+
+        // If this child also extends the 3d context, then recurse into it
+        // looking for more participants.
+        if (child->Extend3DContext()) {
+          child->ComputePreserve3DChildrenOverflow(aOverflowAreas);
+        }
+      }
+    }
+  }
+}
+
+uint32_t
+nsIFrame::GetDepthInFrameTree() const
+{
+  uint32_t result = 0;
+  for (nsContainerFrame* ancestor = GetParent(); ancestor;
+       ancestor = ancestor->GetParent()) {
+    result++;
+  }
+  return result;
+}
+
+void
+nsFrame::ConsiderChildOverflow(nsOverflowAreas& aOverflowAreas,
+                               nsIFrame* aChildFrame)
+{
+  aOverflowAreas.UnionWith(aChildFrame->GetOverflowAreas() +
+                           aChildFrame->GetPosition());
+}
+
+/**
+ * This function takes a frame that is part of a block-in-inline split,
+ * and _if_ that frame is an anonymous block created by an ib split it
+ * returns the block's preceding inline.  This is needed because the
+ * split inline's style context is the parent of the anonymous block's
+ * style context.
+ *
+ * If aFrame is not an anonymous block, null is returned.
+ */
+static nsIFrame*
+GetIBSplitSiblingForAnonymousBlock(const nsIFrame* aFrame)
+{
+  NS_PRECONDITION(aFrame, "Must have a non-null frame!");
+  NS_ASSERTION(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT,
+               "GetIBSplitSibling should only be called on ib-split frames");
+
+  nsIAtom* type = aFrame->StyleContext()->GetPseudo();
+  if (type != nsCSSAnonBoxes::mozAnonymousBlock &&
+      type != nsCSSAnonBoxes::mozAnonymousPositionedBlock) {
+    // it's not an anonymous block
+    return nullptr;
+  }
+
+  // Find the first continuation of the frame.  (Ugh.  This ends up
+  // being O(N^2) when it is called O(N) times.)
+  aFrame = aFrame->FirstContinuation();
+
+  /*
+   * Now look up the nsGkAtoms::IBSplitPrevSibling
+   * property.
+   */
+  nsIFrame *ibSplitSibling =
+    aFrame->Properties().Get(nsIFrame::IBSplitPrevSibling());
+  NS_ASSERTION(ibSplitSibling, "Broken frame tree?");
+  return ibSplitSibling;
+}
+
+/**
+ * Get the parent, corrected for the mangled frame tree resulting from
+ * having a block within an inline.  The result only differs from the
+ * result of |GetParent| when |GetParent| returns an anonymous block
+ * that was created for an element that was 'display: inline' because
+ * that element contained a block.
+ *
+ * Also skip anonymous scrolled-content parents; inherit directly from the
+ * outer scroll frame.
+ */
+static nsIFrame*
+GetCorrectedParent(const nsIFrame* aFrame)
+{
+  nsIFrame* parent = aFrame->GetParent();
+  if (!parent) {
+    return nullptr;
+  }
+
+  // For a table caption we want the _inner_ table frame (unless it's anonymous)
+  // as the style parent.
+  if (aFrame->IsTableCaption()) {
+    nsIFrame* innerTable = parent->PrincipalChildList().FirstChild();
+    if (!innerTable->StyleContext()->GetPseudo()) {
+      return innerTable;
+    }
+  }
+
+  // Table wrappers are always anon boxes; if we're in here for an outer
+  // table, that actually means its the _inner_ table that wants to
+  // know its parent. So get the pseudo of the inner in that case.
+  nsIAtom* pseudo = aFrame->StyleContext()->GetPseudo();
+  if (pseudo == nsCSSAnonBoxes::tableWrapper) {
+    pseudo = aFrame->PrincipalChildList().FirstChild()->StyleContext()->GetPseudo();
+  }
+  return nsFrame::CorrectStyleParentFrame(parent, pseudo);
+}
+
+/* static */
+nsIFrame*
+nsFrame::CorrectStyleParentFrame(nsIFrame* aProspectiveParent,
+                                 nsIAtom* aChildPseudo)
+{
+  NS_PRECONDITION(aProspectiveParent, "Must have a prospective parent");
+
+  // Anon boxes are parented to their actual parent already, except
+  // for non-elements.  Those should not be treated as an anon box.
+  if (aChildPseudo && !nsCSSAnonBoxes::IsNonElement(aChildPseudo) &&
+      nsCSSAnonBoxes::IsAnonBox(aChildPseudo)) {
+    NS_ASSERTION(aChildPseudo != nsCSSAnonBoxes::mozAnonymousBlock &&
+                 aChildPseudo != nsCSSAnonBoxes::mozAnonymousPositionedBlock,
+                 "Should have dealt with kids that have "
+                 "NS_FRAME_PART_OF_IBSPLIT elsewhere");
+    return aProspectiveParent;
+  }
+
+  // Otherwise, walk up out of all anon boxes.  For placeholder frames, walk out
+  // of all pseudo-elements as well.  Otherwise ReparentStyleContext could cause
+  // style data to be out of sync with the frame tree.
+  nsIFrame* parent = aProspectiveParent;
+  do {
+    if (parent->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) {
+      nsIFrame* sibling = GetIBSplitSiblingForAnonymousBlock(parent);
+
+      if (sibling) {
+        // |parent| was a block in an {ib} split; use the inline as
+        // |the style parent.
+        parent = sibling;
+      }
+    }
+      
+    nsIAtom* parentPseudo = parent->StyleContext()->GetPseudo();
+    if (!parentPseudo ||
+        (!nsCSSAnonBoxes::IsAnonBox(parentPseudo) &&
+         // nsPlaceholderFrame pases in nsGkAtoms::placeholderFrame for
+         // aChildPseudo (even though that's not a valid pseudo-type) just to
+         // trigger this behavior of walking up to the nearest non-pseudo
+         // ancestor.
+         aChildPseudo != nsGkAtoms::placeholderFrame)) {
+      return parent;
+    }
+
+    parent = parent->GetParent();
+  } while (parent);
+
+  if (aProspectiveParent->StyleContext()->GetPseudo() ==
+      nsCSSAnonBoxes::viewportScroll) {
+    // aProspectiveParent is the scrollframe for a viewport
+    // and the kids are the anonymous scrollbars
+    return aProspectiveParent;
+  }
+
+  // We can get here if the root element is absolutely positioned.
+  // We can't test for this very accurately, but it can only happen
+  // when the prospective parent is a canvas frame.
+  NS_ASSERTION(aProspectiveParent->GetType() == nsGkAtoms::canvasFrame,
+               "Should have found a parent before this");
+  return nullptr;
+}
+
+nsStyleContext*
+nsFrame::DoGetParentStyleContext(nsIFrame** aProviderFrame) const
+{
+  *aProviderFrame = nullptr;
+  nsFrameManager* fm = PresContext()->FrameManager();
+  if (MOZ_LIKELY(mContent)) {
+    nsIContent* parentContent = mContent->GetFlattenedTreeParent();
+    if (MOZ_LIKELY(parentContent)) {
+      nsIAtom* pseudo = StyleContext()->GetPseudo();
+      if (!pseudo || !mContent->IsElement() ||
+          (!nsCSSAnonBoxes::IsAnonBox(pseudo) &&
+           // Ensure that we don't return the display:contents style
+           // of the parent content for pseudos that have the same content
+           // as their primary frame (like -moz-list-bullets do):
+           mContent->GetPrimaryFrame() == this) ||
+          /* if next is true then it's really a request for the table frame's
+             parent context, see nsTable[Outer]Frame::GetParentStyleContext. */
+          pseudo == nsCSSAnonBoxes::tableWrapper) {
+        nsStyleContext* sc = fm->GetDisplayContentsStyleFor(parentContent);
+        if (MOZ_UNLIKELY(sc)) {
+          return sc;
+        }
+      }
+    } else {
+      if (!StyleContext()->GetPseudo()) {
+        // we're a frame for the root.  We have no style context parent.
+        return nullptr;
+      }
+    }
+  }
+
+  if (!(mState & NS_FRAME_OUT_OF_FLOW)) {
+    /*
+     * If this frame is an anonymous block created when an inline with a block
+     * inside it got split, then the parent style context is on its preceding
+     * inline. We can get to it using GetIBSplitSiblingForAnonymousBlock.
+     */
+    if (mState & NS_FRAME_PART_OF_IBSPLIT) {
+      nsIFrame* ibSplitSibling = GetIBSplitSiblingForAnonymousBlock(this);
+      if (ibSplitSibling) {
+        return (*aProviderFrame = ibSplitSibling)->StyleContext();
+      }
+    }
+
+    // If this frame is one of the blocks that split an inline, we must
+    // return the "special" inline parent, i.e., the parent that this
+    // frame would have if we didn't mangle the frame structure.
+    *aProviderFrame = GetCorrectedParent(this);
+    return *aProviderFrame ? (*aProviderFrame)->StyleContext() : nullptr;
+  }
+
+  // We're an out-of-flow frame.  For out-of-flow frames, we must
+  // resolve underneath the placeholder's parent.  The placeholder is
+  // reached from the first-in-flow.
+  nsIFrame* placeholder = fm->GetPlaceholderFrameFor(FirstInFlow());
+  if (!placeholder) {
+    NS_NOTREACHED("no placeholder frame for out-of-flow frame");
+    *aProviderFrame = GetCorrectedParent(this);
+    return *aProviderFrame ? (*aProviderFrame)->StyleContext() : nullptr;
+  }
+  return placeholder->GetParentStyleContext(aProviderFrame);
+}
+
+void
+nsFrame::GetLastLeaf(nsPresContext* aPresContext, nsIFrame **aFrame)
+{
+  if (!aFrame || !*aFrame)
+    return;
+  nsIFrame *child = *aFrame;
+  //if we are a block frame then go for the last line of 'this'
+  while (1){
+    child = child->PrincipalChildList().FirstChild();
+    if (!child)
+      return;//nothing to do
+    nsIFrame* siblingFrame;
+    nsIContent* content;
+    //ignore anonymous elements, e.g. mozTableAdd* mozTableRemove*
+    //see bug 278197 comment #12 #13 for details
+    while ((siblingFrame = child->GetNextSibling()) &&
+           (content = siblingFrame->GetContent()) &&
+           !content->IsRootOfNativeAnonymousSubtree())
+      child = siblingFrame;
+    *aFrame = child;
+  }
+}
+
+void
+nsFrame::GetFirstLeaf(nsPresContext* aPresContext, nsIFrame **aFrame)
+{
+  if (!aFrame || !*aFrame)
+    return;
+  nsIFrame *child = *aFrame;
+  while (1){
+    child = child->PrincipalChildList().FirstChild();
+    if (!child)
+      return;//nothing to do
+    *aFrame = child;
+  }
+}
+
+/* virtual */ bool
+nsIFrame::IsFocusable(int32_t *aTabIndex, bool aWithMouse)
+{
+  int32_t tabIndex = -1;
+  if (aTabIndex) {
+    *aTabIndex = -1; // Default for early return is not focusable
+  }
+  bool isFocusable = false;
+
+  if (mContent && mContent->IsElement() && IsVisibleConsideringAncestors() &&
+      StyleContext()->GetPseudo() != nsCSSAnonBoxes::anonymousFlexItem &&
+      StyleContext()->GetPseudo() != nsCSSAnonBoxes::anonymousGridItem) {
+    const nsStyleUserInterface* ui = StyleUserInterface();
+    if (ui->mUserFocus != StyleUserFocus::Ignore &&
+        ui->mUserFocus != StyleUserFocus::None) {
+      // Pass in default tabindex of -1 for nonfocusable and 0 for focusable
+      tabIndex = 0;
+    }
+    isFocusable = mContent->IsFocusable(&tabIndex, aWithMouse);
+    if (!isFocusable && !aWithMouse &&
+        GetType() == nsGkAtoms::scrollFrame &&
+        mContent->IsHTMLElement() &&
+        !mContent->IsRootOfNativeAnonymousSubtree() &&
+        mContent->GetParent() &&
+        !mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
+      // Elements with scrollable view are focusable with script & tabbable
+      // Otherwise you couldn't scroll them with keyboard, which is
+      // an accessibility issue (e.g. Section 508 rules)
+      // However, we don't make them to be focusable with the mouse,
+      // because the extra focus outlines are considered unnecessarily ugly.
+      // When clicked on, the selection position within the element 
+      // will be enough to make them keyboard scrollable.
+      nsIScrollableFrame *scrollFrame = do_QueryFrame(this);
+      if (scrollFrame &&
+          !scrollFrame->GetScrollbarStyles().IsHiddenInBothDirections() &&
+          !scrollFrame->GetScrollRange().IsEqualEdges(nsRect(0, 0, 0, 0))) {
+        // Scroll bars will be used for overflow
+        isFocusable = true;
+        tabIndex = 0;
+      }
+    }
+  }
+
+  if (aTabIndex) {
+    *aTabIndex = tabIndex;
+  }
+  return isFocusable;
+}
+
+/**
+ * @return true if this text frame ends with a newline character which is
+ * treated as preformatted. It should return false if this is not a text frame.
+ */
+bool
+nsIFrame::HasSignificantTerminalNewline() const
+{
+  return false;
+}
+
+static uint8_t
+ConvertSVGDominantBaselineToVerticalAlign(uint8_t aDominantBaseline)
+{
+  // Most of these are approximate mappings.
+  switch (aDominantBaseline) {
+  case NS_STYLE_DOMINANT_BASELINE_HANGING:
+  case NS_STYLE_DOMINANT_BASELINE_TEXT_BEFORE_EDGE:
+    return NS_STYLE_VERTICAL_ALIGN_TEXT_TOP;
+  case NS_STYLE_DOMINANT_BASELINE_TEXT_AFTER_EDGE:
+  case NS_STYLE_DOMINANT_BASELINE_IDEOGRAPHIC:
+    return NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM;
+  case NS_STYLE_DOMINANT_BASELINE_CENTRAL:
+  case NS_STYLE_DOMINANT_BASELINE_MIDDLE:
+  case NS_STYLE_DOMINANT_BASELINE_MATHEMATICAL:
+    return NS_STYLE_VERTICAL_ALIGN_MIDDLE;
+  case NS_STYLE_DOMINANT_BASELINE_AUTO:
+  case NS_STYLE_DOMINANT_BASELINE_ALPHABETIC:
+    return NS_STYLE_VERTICAL_ALIGN_BASELINE;
+  case NS_STYLE_DOMINANT_BASELINE_USE_SCRIPT:
+  case NS_STYLE_DOMINANT_BASELINE_NO_CHANGE:
+  case NS_STYLE_DOMINANT_BASELINE_RESET_SIZE:
+    // These three should not simply map to 'baseline', but we don't
+    // support the complex baseline model that SVG 1.1 has and which
+    // css3-linebox now defines.
+    return NS_STYLE_VERTICAL_ALIGN_BASELINE;
+  default:
+    NS_NOTREACHED("unexpected aDominantBaseline value");
+    return NS_STYLE_VERTICAL_ALIGN_BASELINE;
+  }
+}
+
+uint8_t
+nsIFrame::VerticalAlignEnum() const
+{
+  if (IsSVGText()) {
+    uint8_t dominantBaseline;
+    for (const nsIFrame* frame = this; frame; frame = frame->GetParent()) {
+      dominantBaseline = frame->StyleSVGReset()->mDominantBaseline;
+      if (dominantBaseline != NS_STYLE_DOMINANT_BASELINE_AUTO ||
+          frame->GetType() == nsGkAtoms::svgTextFrame) {
+        break;
+      }
+    }
+    return ConvertSVGDominantBaselineToVerticalAlign(dominantBaseline);
+  }
+
+  const nsStyleCoord& verticalAlign = StyleDisplay()->mVerticalAlign;
+  if (verticalAlign.GetUnit() == eStyleUnit_Enumerated) {
+    return verticalAlign.GetIntValue();
+  }
+
+  return eInvalidVerticalAlign;
+}
+
+/* static */
+void nsFrame::FillCursorInformationFromStyle(const nsStyleUserInterface* ui,
+                                             nsIFrame::Cursor& aCursor)
+{
+  aCursor.mCursor = ui->mCursor;
+  aCursor.mHaveHotspot = false;
+  aCursor.mLoading = false;
+  aCursor.mHotspotX = aCursor.mHotspotY = 0.0f;
+
+  for (const nsCursorImage& item : ui->mCursorImages) {
+    uint32_t status;
+    nsresult rv = item.GetImage()->GetImageStatus(&status);
+    if (NS_SUCCEEDED(rv)) {
+      if (!(status & imgIRequest::STATUS_LOAD_COMPLETE)) {
+        // If we are falling back because any cursor before is loading,
+        // let the consumer know.
+        aCursor.mLoading = true;
+      } else if (!(status & imgIRequest::STATUS_ERROR)) {
+        // This is the one we want
+        item.GetImage()->GetImage(getter_AddRefs(aCursor.mContainer));
+        aCursor.mHaveHotspot = item.mHaveHotspot;
+        aCursor.mHotspotX = item.mHotspotX;
+        aCursor.mHotspotY = item.mHotspotY;
+        break;
+      }
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsFrame::RefreshSizeCache(nsBoxLayoutState& aState)
+{
+  // XXXbz this comment needs some rewriting to make sense in the
+  // post-reflow-branch world.
+  
+  // Ok we need to compute our minimum, preferred, and maximum sizes.
+  // 1) Maximum size. This is easy. Its infinite unless it is overloaded by CSS.
+  // 2) Preferred size. This is a little harder. This is the size the block would be 
+  //      if it were laid out on an infinite canvas. So we can get this by reflowing
+  //      the block with and INTRINSIC width and height. We can also do a nice optimization
+  //      for incremental reflow. If the reflow is incremental then we can pass a flag to 
+  //      have the block compute the preferred width for us! Preferred height can just be
+  //      the minimum height;
+  // 3) Minimum size. This is a toughy. We can pass the block a flag asking for the max element
+  //    size. That would give us the width. Unfortunately you can only ask for a maxElementSize
+  //    during an incremental reflow. So on other reflows we will just have to use 0.
+  //    The min height on the other hand is fairly easy we need to get the largest
+  //    line height. This can be done with the line iterator.
+
+  // if we do have a rendering context
+  nsRenderingContext* rendContext = aState.GetRenderingContext();
+  if (rendContext) {
+    nsPresContext* presContext = aState.PresContext();
+
+    // If we don't have any HTML constraints and it's a resize, then nothing in the block
+    // could have changed, so no refresh is necessary.
+    nsBoxLayoutMetrics* metrics = BoxMetrics();
+    if (!DoesNeedRecalc(metrics->mBlockPrefSize))
+      return NS_OK;
+
+    // the rect we plan to size to.
+    nsRect rect = GetRect();
+
+    nsMargin bp(0,0,0,0);
+    GetXULBorderAndPadding(bp);
+
+    {
+      // If we're a container for font size inflation, then shrink
+      // wrapping inside of us should not apply font size inflation.
+      AutoMaybeDisableFontInflation an(this);
+
+      metrics->mBlockPrefSize.width =
+        GetPrefISize(rendContext) + bp.LeftRight();
+      metrics->mBlockMinSize.width =
+        GetMinISize(rendContext) + bp.LeftRight();
+    }
+
+    // do the nasty.
+    const WritingMode wm = aState.OuterReflowInput() ?
+      aState.OuterReflowInput()->GetWritingMode() : GetWritingMode();
+    ReflowOutput desiredSize(wm);
+    BoxReflow(aState, presContext, desiredSize, rendContext,
+              rect.x, rect.y,
+              metrics->mBlockPrefSize.width, NS_UNCONSTRAINEDSIZE);
+
+    metrics->mBlockMinSize.height = 0;
+    // ok we need the max ascent of the items on the line. So to do this
+    // ask the block for its line iterator. Get the max ascent.
+    nsAutoLineIterator lines = GetLineIterator();
+    if (lines) 
+    {
+      metrics->mBlockMinSize.height = 0;
+      int count = 0;
+      nsIFrame* firstFrame = nullptr;
+      int32_t framesOnLine;
+      nsRect lineBounds;
+
+      do {
+         lines->GetLine(count, &firstFrame, &framesOnLine, lineBounds);
+
+         if (lineBounds.height > metrics->mBlockMinSize.height)
+           metrics->mBlockMinSize.height = lineBounds.height;
+
+         count++;
+      } while(firstFrame);
+    } else {
+      metrics->mBlockMinSize.height = desiredSize.Height();
+    }
+
+    metrics->mBlockPrefSize.height = metrics->mBlockMinSize.height;
+
+    if (desiredSize.BlockStartAscent() ==
+        ReflowOutput::ASK_FOR_BASELINE) {
+      if (!nsLayoutUtils::GetFirstLineBaseline(wm, this,
+                                               &metrics->mBlockAscent))
+        metrics->mBlockAscent = GetLogicalBaseline(wm);
+    } else {
+      metrics->mBlockAscent = desiredSize.BlockStartAscent();
+    }
+
+#ifdef DEBUG_adaptor
+    printf("min=(%d,%d), pref=(%d,%d), ascent=%d\n", metrics->mBlockMinSize.width,
+                                                     metrics->mBlockMinSize.height,
+                                                     metrics->mBlockPrefSize.width,
+                                                     metrics->mBlockPrefSize.height,
+                                                     metrics->mBlockAscent);
+#endif
+  }
+
+  return NS_OK;
+}
+
+/* virtual */ nsILineIterator*
+nsFrame::GetLineIterator()
+{
+  return nullptr;
+}
+
+nsSize
+nsFrame::GetXULPrefSize(nsBoxLayoutState& aState)
+{
+  nsSize size(0,0);
+  DISPLAY_PREF_SIZE(this, size);
+  // If the size is cached, and there are no HTML constraints that we might
+  // be depending on, then we just return the cached size.
+  nsBoxLayoutMetrics *metrics = BoxMetrics();
+  if (!DoesNeedRecalc(metrics->mPrefSize)) {
+    return metrics->mPrefSize;
+  }
+
+  if (IsXULCollapsed())
+    return size;
+
+  // get our size in CSS.
+  bool widthSet, heightSet;
+  bool completelyRedefined = nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet);
+
+  // Refresh our caches with new sizes.
+  if (!completelyRedefined) {
+    RefreshSizeCache(aState);
+    nsSize blockSize = metrics->mBlockPrefSize;
+
+    // notice we don't need to add our borders or padding
+    // in. That's because the block did it for us.
+    if (!widthSet)
+      size.width = blockSize.width;
+    if (!heightSet)
+      size.height = blockSize.height;
+  }
+
+  metrics->mPrefSize = size;
+  return size;
+}
+
+nsSize
+nsFrame::GetXULMinSize(nsBoxLayoutState& aState)
+{
+  nsSize size(0,0);
+  DISPLAY_MIN_SIZE(this, size);
+  // Don't use the cache if we have HTMLReflowInput constraints --- they might have changed
+  nsBoxLayoutMetrics *metrics = BoxMetrics();
+  if (!DoesNeedRecalc(metrics->mMinSize)) {
+    size = metrics->mMinSize;
+    return size;
+  }
+
+  if (IsXULCollapsed())
+    return size;
+
+  // get our size in CSS.
+  bool widthSet, heightSet;
+  bool completelyRedefined =
+    nsIFrame::AddXULMinSize(aState, this, size, widthSet, heightSet);
+
+  // Refresh our caches with new sizes.
+  if (!completelyRedefined) {
+    RefreshSizeCache(aState);
+    nsSize blockSize = metrics->mBlockMinSize;
+
+    if (!widthSet)
+      size.width = blockSize.width;
+    if (!heightSet)
+      size.height = blockSize.height;
+  }
+
+  metrics->mMinSize = size;
+  return size;
+}
+
+nsSize
+nsFrame::GetXULMaxSize(nsBoxLayoutState& aState)
+{
+  nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
+  DISPLAY_MAX_SIZE(this, size);
+  // Don't use the cache if we have HTMLReflowInput constraints --- they might have changed
+  nsBoxLayoutMetrics *metrics = BoxMetrics();
+  if (!DoesNeedRecalc(metrics->mMaxSize)) {
+    size = metrics->mMaxSize;
+    return size;
+  }
+
+  if (IsXULCollapsed())
+    return size;
+
+  size = nsBox::GetXULMaxSize(aState);
+  metrics->mMaxSize = size;
+
+  return size;
+}
+
+nscoord
+nsFrame::GetXULFlex()
+{
+  nsBoxLayoutMetrics *metrics = BoxMetrics();
+  if (!DoesNeedRecalc(metrics->mFlex))
+     return metrics->mFlex;
+
+  metrics->mFlex = nsBox::GetXULFlex();
+
+  return metrics->mFlex;
+}
+
+nscoord
+nsFrame::GetXULBoxAscent(nsBoxLayoutState& aState)
+{
+  nsBoxLayoutMetrics *metrics = BoxMetrics();
+  if (!DoesNeedRecalc(metrics->mAscent))
+    return metrics->mAscent;
+
+  if (IsXULCollapsed()) {
+    metrics->mAscent = 0;
+  } else {
+    // Refresh our caches with new sizes.
+    RefreshSizeCache(aState);
+    metrics->mAscent = metrics->mBlockAscent;
+  }
+
+  return metrics->mAscent;
+}
+
+nsresult
+nsFrame::DoXULLayout(nsBoxLayoutState& aState)
+{
+  nsRect ourRect(mRect);
+
+  nsRenderingContext* rendContext = aState.GetRenderingContext();
+  nsPresContext* presContext = aState.PresContext();
+  WritingMode ourWM = GetWritingMode();
+  const WritingMode outerWM = aState.OuterReflowInput() ?
+    aState.OuterReflowInput()->GetWritingMode() : ourWM;
+  ReflowOutput desiredSize(outerWM);
+  LogicalSize ourSize = GetLogicalSize(outerWM);
+
+  if (rendContext) {
+
+    BoxReflow(aState, presContext, desiredSize, rendContext,
+              ourRect.x, ourRect.y, ourRect.width, ourRect.height);
+
+    if (IsXULCollapsed()) {
+      SetSize(nsSize(0, 0));
+    } else {
+
+      // if our child needs to be bigger. This might happend with
+      // wrapping text. There is no way to predict its height until we
+      // reflow it. Now that we know the height reshuffle upward.
+      if (desiredSize.ISize(outerWM) > ourSize.ISize(outerWM) ||
+          desiredSize.BSize(outerWM) > ourSize.BSize(outerWM)) {
+
+#ifdef DEBUG_GROW
+        XULDumpBox(stdout);
+        printf(" GREW from (%d,%d) -> (%d,%d)\n",
+               ourSize.ISize(outerWM), ourSize.BSize(outerWM),
+               desiredSize.ISize(outerWM), desiredSize.BSize(outerWM));
+#endif
+
+        if (desiredSize.ISize(outerWM) > ourSize.ISize(outerWM)) {
+          ourSize.ISize(outerWM) = desiredSize.ISize(outerWM);
+        }
+
+        if (desiredSize.BSize(outerWM) > ourSize.BSize(outerWM)) {
+          ourSize.BSize(outerWM) = desiredSize.BSize(outerWM);
+        }
+      }
+
+      // ensure our size is what we think is should be. Someone could have
+      // reset the frame to be smaller or something dumb like that. 
+      SetSize(ourSize.ConvertTo(ourWM, outerWM));
+    }
+  }
+
+  // Should we do this if IsXULCollapsed() is true?
+  LogicalSize size(GetLogicalSize(outerWM));
+  desiredSize.ISize(outerWM) = size.ISize(outerWM);
+  desiredSize.BSize(outerWM) = size.BSize(outerWM);
+  desiredSize.UnionOverflowAreasWithDesiredBounds();
+
+  if (HasAbsolutelyPositionedChildren()) {
+    // Set up a |reflowInput| to pass into ReflowAbsoluteFrames
+    ReflowInput reflowInput(aState.PresContext(), this,
+                                  aState.GetRenderingContext(),
+                                  LogicalSize(ourWM, ISize(),
+                                              NS_UNCONSTRAINEDSIZE),
+                                  ReflowInput::DUMMY_PARENT_REFLOW_STATE);
+
+    AddStateBits(NS_FRAME_IN_REFLOW);
+    // Set up a |reflowStatus| to pass into ReflowAbsoluteFrames
+    // (just a dummy value; hopefully that's OK)
+    nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+    ReflowAbsoluteFrames(aState.PresContext(), desiredSize,
+                         reflowInput, reflowStatus);
+    RemoveStateBits(NS_FRAME_IN_REFLOW);
+  }
+
+  nsSize oldSize(ourRect.Size());
+  FinishAndStoreOverflow(desiredSize.mOverflowAreas,
+                         size.GetPhysicalSize(outerWM), &oldSize);
+
+  SyncLayout(aState);
+
+  return NS_OK;
+}
+
+void
+nsFrame::BoxReflow(nsBoxLayoutState&        aState,
+                   nsPresContext*           aPresContext,
+                   ReflowOutput&     aDesiredSize,
+                   nsRenderingContext*     aRenderingContext,
+                   nscoord                  aX,
+                   nscoord                  aY,
+                   nscoord                  aWidth,
+                   nscoord                  aHeight,
+                   bool                     aMoveFrame)
+{
+  DO_GLOBAL_REFLOW_COUNT("nsBoxToBlockAdaptor");
+
+#ifdef DEBUG_REFLOW
+  nsAdaptorAddIndents();
+  printf("Reflowing: ");
+  nsFrame::ListTag(stdout, mFrame);
+  printf("\n");
+  gIndent2++;
+#endif
+
+  nsBoxLayoutMetrics *metrics = BoxMetrics();
+  nsReflowStatus status = NS_FRAME_COMPLETE;
+  WritingMode wm = aDesiredSize.GetWritingMode();
+
+  bool needsReflow = NS_SUBTREE_DIRTY(this);
+
+  // if we don't need a reflow then 
+  // lets see if we are already that size. Yes? then don't even reflow. We are done.
+  if (!needsReflow) {
+      
+      if (aWidth != NS_INTRINSICSIZE && aHeight != NS_INTRINSICSIZE) {
+      
+          // if the new calculated size has a 0 width or a 0 height
+          if ((metrics->mLastSize.width == 0 || metrics->mLastSize.height == 0) && (aWidth == 0 || aHeight == 0)) {
+               needsReflow = false;
+               aDesiredSize.Width() = aWidth; 
+               aDesiredSize.Height() = aHeight; 
+               SetSize(aDesiredSize.Size(wm).ConvertTo(GetWritingMode(), wm));
+          } else {
+            aDesiredSize.Width() = metrics->mLastSize.width;
+            aDesiredSize.Height() = metrics->mLastSize.height;
+
+            // remove the margin. The rect of our child does not include it but our calculated size does.
+            // don't reflow if we are already the right size
+            if (metrics->mLastSize.width == aWidth && metrics->mLastSize.height == aHeight)
+                  needsReflow = false;
+            else
+                  needsReflow = true;
+   
+          }
+      } else {
+          // if the width or height are intrinsic alway reflow because
+          // we don't know what it should be.
+         needsReflow = true;
+      }
+  }
+
+  // ok now reflow the child into the spacers calculated space
+  if (needsReflow) {
+
+    aDesiredSize.ClearSize();
+
+    // create a reflow state to tell our child to flow at the given size.
+
+    // Construct a bogus parent reflow state so that there's a usable
+    // containing block reflow state.
+    nsMargin margin(0,0,0,0);
+    GetXULMargin(margin);
+
+    nsSize parentSize(aWidth, aHeight);
+    if (parentSize.height != NS_INTRINSICSIZE)
+      parentSize.height += margin.TopBottom();
+    if (parentSize.width != NS_INTRINSICSIZE)
+      parentSize.width += margin.LeftRight();
+
+    nsIFrame *parentFrame = GetParent();
+    nsFrameState savedState = parentFrame->GetStateBits();
+    WritingMode parentWM = parentFrame->GetWritingMode();
+    ReflowInput
+      parentReflowInput(aPresContext, parentFrame, aRenderingContext,
+                        LogicalSize(parentWM, parentSize),
+                        ReflowInput::DUMMY_PARENT_REFLOW_STATE);
+    parentFrame->RemoveStateBits(~nsFrameState(0));
+    parentFrame->AddStateBits(savedState);
+
+    // This may not do very much useful, but it's probably worth trying.
+    if (parentSize.width != NS_INTRINSICSIZE)
+      parentReflowInput.SetComputedWidth(std::max(parentSize.width, 0));
+    if (parentSize.height != NS_INTRINSICSIZE)
+      parentReflowInput.SetComputedHeight(std::max(parentSize.height, 0));
+    parentReflowInput.ComputedPhysicalMargin().SizeTo(0, 0, 0, 0);
+    // XXX use box methods
+    parentFrame->GetXULPadding(parentReflowInput.ComputedPhysicalPadding());
+    parentFrame->GetXULBorder(parentReflowInput.ComputedPhysicalBorderPadding());
+    parentReflowInput.ComputedPhysicalBorderPadding() +=
+      parentReflowInput.ComputedPhysicalPadding();
+
+    // Construct the parent chain manually since constructing it normally
+    // messes up dimensions.
+    const ReflowInput *outerReflowInput = aState.OuterReflowInput();
+    NS_ASSERTION(!outerReflowInput || outerReflowInput->mFrame != this,
+                 "in and out of XUL on a single frame?");
+    const ReflowInput* parentRI;
+    if (outerReflowInput && outerReflowInput->mFrame == parentFrame) {
+      // We're a frame (such as a text control frame) that jumps into
+      // box reflow and then straight out of it on the child frame.
+      // This means we actually have a real parent reflow state.
+      // nsLayoutUtils::InflationMinFontSizeFor used to need this to be
+      // linked up correctly for text control frames, so do so here).
+      parentRI = outerReflowInput;
+    } else {
+      parentRI = &parentReflowInput;
+    }
+
+    // XXX Is it OK that this reflow state has only one ancestor?
+    // (It used to have a bogus parent, skipping all the boxes).
+    WritingMode wm = GetWritingMode();
+    LogicalSize logicalSize(wm, nsSize(aWidth, aHeight));
+    logicalSize.BSize(wm) = NS_INTRINSICSIZE;
+    ReflowInput reflowInput(aPresContext, *parentRI, this,
+                                  logicalSize, nullptr,
+                                  ReflowInput::DUMMY_PARENT_REFLOW_STATE);
+
+    // XXX_jwir3: This is somewhat fishy. If this is actually changing the value
+    //            here (which it might be), then we should make sure that it's
+    //            correct the first time around, rather than changing it later.
+    reflowInput.mCBReflowInput = parentRI;
+
+    reflowInput.mReflowDepth = aState.GetReflowDepth();
+
+    // mComputedWidth and mComputedHeight are content-box, not
+    // border-box
+    if (aWidth != NS_INTRINSICSIZE) {
+      nscoord computedWidth =
+        aWidth - reflowInput.ComputedPhysicalBorderPadding().LeftRight();
+      computedWidth = std::max(computedWidth, 0);
+      reflowInput.SetComputedWidth(computedWidth);
+    }
+
+    // Most child frames of box frames (e.g. subdocument or scroll frames)
+    // need to be constrained to the provided size and overflow as necessary.
+    // The one exception are block frames, because we need to know their
+    // natural height excluding any overflow area which may be caused by
+    // various CSS effects such as shadow or outline.
+    if (!IsFrameOfType(eBlockFrame)) {
+      if (aHeight != NS_INTRINSICSIZE) {
+        nscoord computedHeight =
+          aHeight - reflowInput.ComputedPhysicalBorderPadding().TopBottom();
+        computedHeight = std::max(computedHeight, 0);
+        reflowInput.SetComputedHeight(computedHeight);
+      } else {
+        reflowInput.SetComputedHeight(
+          ComputeSize(aRenderingContext, wm,
+                      logicalSize,
+                      logicalSize.ISize(wm),
+                      reflowInput.ComputedLogicalMargin().Size(wm),
+                      reflowInput.ComputedLogicalBorderPadding().Size(wm) -
+                        reflowInput.ComputedLogicalPadding().Size(wm),
+                      reflowInput.ComputedLogicalPadding().Size(wm),
+                      ComputeSizeFlags::eDefault).Height(wm));
+      }
+    }
+
+    // Box layout calls SetRect before XULLayout, whereas non-box layout
+    // calls SetRect after Reflow.
+    // XXX Perhaps we should be doing this by twiddling the rect back to
+    // mLastSize before calling Reflow and then switching it back, but
+    // However, mLastSize can also be the size passed to BoxReflow by
+    // RefreshSizeCache, so that doesn't really make sense.
+    if (metrics->mLastSize.width != aWidth) {
+      reflowInput.SetHResize(true);
+
+      // When font size inflation is enabled, a horizontal resize
+      // requires a full reflow.  See ReflowInput::InitResizeFlags
+      // for more details.
+      if (nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) {
+        AddStateBits(NS_FRAME_IS_DIRTY);
+      }
+    }
+    if (metrics->mLastSize.height != aHeight) {
+      reflowInput.SetVResize(true);
+    }
+
+    #ifdef DEBUG_REFLOW
+      nsAdaptorAddIndents();
+      printf("Size=(%d,%d)\n",reflowInput.ComputedWidth(),
+             reflowInput.ComputedHeight());
+      nsAdaptorAddIndents();
+      nsAdaptorPrintReason(reflowInput);
+      printf("\n");
+    #endif
+
+       // place the child and reflow
+
+    Reflow(aPresContext, aDesiredSize, reflowInput, status);
+
+    NS_ASSERTION(NS_FRAME_IS_COMPLETE(status), "bad status");
+
+    uint32_t layoutFlags = aState.LayoutFlags();
+    nsContainerFrame::FinishReflowChild(this, aPresContext, aDesiredSize,
+                                        &reflowInput, aX, aY, layoutFlags | NS_FRAME_NO_MOVE_FRAME);
+
+    // Save the ascent.  (bug 103925)
+    if (IsXULCollapsed()) {
+      metrics->mAscent = 0;
+    } else {
+      if (aDesiredSize.BlockStartAscent() ==
+          ReflowOutput::ASK_FOR_BASELINE) {
+        if (!nsLayoutUtils::GetFirstLineBaseline(wm, this, &metrics->mAscent))
+          metrics->mAscent = GetLogicalBaseline(wm);
+      } else
+        metrics->mAscent = aDesiredSize.BlockStartAscent();
+    }
+
+  } else {
+    aDesiredSize.SetBlockStartAscent(metrics->mBlockAscent);
+  }
+
+#ifdef DEBUG_REFLOW
+  if (aHeight != NS_INTRINSICSIZE && aDesiredSize.Height() != aHeight)
+  {
+          nsAdaptorAddIndents();
+          printf("*****got taller!*****\n");
+         
+  }
+  if (aWidth != NS_INTRINSICSIZE && aDesiredSize.Width() != aWidth)
+  {
+          nsAdaptorAddIndents();
+          printf("*****got wider!******\n");
+         
+  }
+#endif
+
+  if (aWidth == NS_INTRINSICSIZE)
+     aWidth = aDesiredSize.Width();
+
+  if (aHeight == NS_INTRINSICSIZE)
+     aHeight = aDesiredSize.Height();
+
+  metrics->mLastSize.width = aDesiredSize.Width();
+  metrics->mLastSize.height = aDesiredSize.Height();
+
+#ifdef DEBUG_REFLOW
+  gIndent2--;
+#endif
+}
+
+nsBoxLayoutMetrics*
+nsFrame::BoxMetrics() const
+{
+  nsBoxLayoutMetrics* metrics = Properties().Get(BoxMetricsProperty());
+  NS_ASSERTION(metrics, "A box layout method was called but InitBoxMetrics was never called");
+  return metrics;
+}
+
+/* static */ void
+nsIFrame::AddInPopupStateBitToDescendants(nsIFrame* aFrame)
+{
+  if (!aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP) &&
+      aFrame->TrackingVisibility()) {
+    // Assume all frames in popups are visible.
+    aFrame->IncApproximateVisibleCount();
+  }
+
+  aFrame->AddStateBits(NS_FRAME_IN_POPUP);
+
+  AutoTArray<nsIFrame::ChildList,4> childListArray;
+  aFrame->GetCrossDocChildLists(&childListArray);
+
+  nsIFrame::ChildListArrayIterator lists(childListArray);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      AddInPopupStateBitToDescendants(childFrames.get());
+    }
+  }
+}
+
+/* static */ void
+nsIFrame::RemoveInPopupStateBitFromDescendants(nsIFrame* aFrame)
+{
+  if (!aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP) ||
+      nsLayoutUtils::IsPopup(aFrame)) {
+    return;
+  }
+
+  aFrame->RemoveStateBits(NS_FRAME_IN_POPUP);
+
+  if (aFrame->TrackingVisibility()) {
+    // We assume all frames in popups are visible, so this decrement balances
+    // out the increment in AddInPopupStateBitToDescendants above.
+    aFrame->DecApproximateVisibleCount();
+  }
+
+  AutoTArray<nsIFrame::ChildList,4> childListArray;
+  aFrame->GetCrossDocChildLists(&childListArray);
+
+  nsIFrame::ChildListArrayIterator lists(childListArray);
+  for (; !lists.IsDone(); lists.Next()) {
+    nsFrameList::Enumerator childFrames(lists.CurrentList());
+    for (; !childFrames.AtEnd(); childFrames.Next()) {
+      RemoveInPopupStateBitFromDescendants(childFrames.get());
+    }
+  }
+}
+
+void
+nsIFrame::SetParent(nsContainerFrame* aParent)
+{
+  // Note that the current mParent may already be destroyed at this point.
+  mParent = aParent;
+  if (::IsXULBoxWrapped(this)) {
+    ::InitBoxMetrics(this, true);
+  } else {
+    // We could call Properties().Delete(BoxMetricsProperty()); here but
+    // that's kind of slow and re-parenting in such a way that we were
+    // IsXULBoxWrapped() before but not now should be very rare, so we'll just
+    // keep this unused frame property until this frame dies instead.
+  }
+
+  if (GetStateBits() & (NS_FRAME_HAS_VIEW | NS_FRAME_HAS_CHILD_WITH_VIEW)) {
+    for (nsIFrame* f = aParent;
+         f && !(f->GetStateBits() & NS_FRAME_HAS_CHILD_WITH_VIEW);
+         f = f->GetParent()) {
+      f->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
+    }
+  }
+
+  if (HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
+    for (nsIFrame* f = aParent; f; f = f->GetParent()) {
+      if (f->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
+        break;
+      }
+      f->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
+    }
+  }
+
+  if (HasAnyStateBits(NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
+    for (nsIFrame* f = aParent; f; f = f->GetParent()) {
+      if (f->HasAnyStateBits(NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
+        break;
+      }
+      f->AddStateBits(NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE);
+    }
+  }
+
+  if (HasInvalidFrameInSubtree()) {
+    for (nsIFrame* f = aParent;
+         f && !f->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT | NS_FRAME_IS_NONDISPLAY);
+         f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
+      f->AddStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT);
+    }
+  }
+
+  if (aParent->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
+    AddInPopupStateBitToDescendants(this);
+  } else {
+    RemoveInPopupStateBitFromDescendants(this);
+  }
+  
+  // If our new parent only has invalid children, then we just invalidate
+  // ourselves too. This is probably faster than clearing the flag all
+  // the way up the frame tree.
+  if (aParent->HasAnyStateBits(NS_FRAME_ALL_DESCENDANTS_NEED_PAINT)) {
+    InvalidateFrame();
+  }
+}
+
+void
+nsIFrame::CreateOwnLayerIfNeeded(nsDisplayListBuilder* aBuilder, 
+                                 nsDisplayList* aList)
+{
+  if (GetContent() &&
+      GetContent()->IsXULElement() &&
+      GetContent()->HasAttr(kNameSpaceID_None, nsGkAtoms::layer)) {
+    aList->AppendNewToTop(new (aBuilder) 
+        nsDisplayOwnLayer(aBuilder, this, aList));
+  }
+}
+
+bool
+nsIFrame::IsSelected() const
+{
+  return (GetContent() && GetContent()->IsSelectionDescendant()) ?
+    IsFrameSelected() : false;
+}
+
+/*static*/ void
+nsIFrame::DestroyContentArray(ContentArray* aArray)
+{
+  for (nsIContent* content : *aArray) {
+    content->UnbindFromTree();
+    NS_RELEASE(content);
+  }
+  delete aArray;
+}
+
+bool
+nsIFrame::IsPseudoStackingContextFromStyle() {
+  // If you change this, also change the computation of pseudoStackingContext
+  // in BuildDisplayListForChild()
+  if (StyleEffects()->mOpacity != 1.0f) {
+    return true;
+  }
+  const nsStyleDisplay* disp = StyleDisplay();
+  return disp->IsAbsPosContainingBlock(this) ||
+         disp->IsFloating(this) ||
+         (disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_STACKING_CONTEXT);
+}
+
+Element*
+nsIFrame::GetPseudoElement(CSSPseudoElementType aType)
+{
+  nsIFrame* frame = nullptr;
+
+  if (aType == CSSPseudoElementType::before) {
+    frame = nsLayoutUtils::GetBeforeFrame(this);
+  } else if (aType == CSSPseudoElementType::after) {
+    frame = nsLayoutUtils::GetAfterFrame(this);
+  }
+
+  if (frame) {
+    nsIContent* content = frame->GetContent();
+    if (content->IsElement()) {
+      return content->AsElement();
+    }
+  }
+
+  return nullptr;
+}
+
+static bool
+IsFrameScrolledOutOfView(nsIFrame *aFrame)
+{
+  nsIScrollableFrame* scrollableFrame =
+    nsLayoutUtils::GetNearestScrollableFrame(aFrame,
+      nsLayoutUtils::SCROLLABLE_SAME_DOC |
+      nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+  if (!scrollableFrame) {
+    return false;
+  }
+
+  nsIFrame *scrollableParent = do_QueryFrame(scrollableFrame);
+  nsRect rect = aFrame->GetVisualOverflowRect();
+
+  nsRect transformedRect =
+    nsLayoutUtils::TransformFrameRectToAncestor(aFrame,
+                                                rect,
+                                                scrollableParent);
+
+  nsRect scrollableRect = scrollableParent->GetVisualOverflowRect();
+  if (!transformedRect.Intersects(scrollableRect)) {
+    return true;
+  }
+
+  nsIFrame* parent = scrollableParent->GetParent();
+  if (!parent) {
+    return false;
+  }
+
+  return IsFrameScrolledOutOfView(parent);
+}
+
+bool
+nsIFrame::IsScrolledOutOfView()
+{
+  return IsFrameScrolledOutOfView(this);
+}
+
+nsIFrame::CaretPosition::CaretPosition()
+  : mContentOffset(0)
+{
+}
+
+nsIFrame::CaretPosition::~CaretPosition()
+{
+}
+
+bool
+nsFrame::HasCSSAnimations()
+{
+  auto collection =
+    AnimationCollection<CSSAnimation>::GetAnimationCollection(this);
+  return collection && collection->mAnimations.Length() > 0;
+}
+
+bool
+nsFrame::HasCSSTransitions()
+{
+  auto collection =
+    AnimationCollection<CSSTransition>::GetAnimationCollection(this);
+  return collection && collection->mAnimations.Length() > 0;
+}
+
+// Box layout debugging
+#ifdef DEBUG_REFLOW
+int32_t gIndent2 = 0;
+
+void
+nsAdaptorAddIndents()
+{
+    for(int32_t i=0; i < gIndent2; i++)
+    {
+        printf(" ");
+    }
+}
+
+void
+nsAdaptorPrintReason(ReflowInput& aReflowInput)
+{
+    char* reflowReasonString;
+
+    switch(aReflowInput.reason) 
+    {
+        case eReflowReason_Initial:
+          reflowReasonString = "initial";
+          break;
+
+        case eReflowReason_Resize:
+          reflowReasonString = "resize";
+          break;
+        case eReflowReason_Dirty:
+          reflowReasonString = "dirty";
+          break;
+        case eReflowReason_StyleChange:
+          reflowReasonString = "stylechange";
+          break;
+        case eReflowReason_Incremental: 
+        {
+            switch (aReflowInput.reflowCommand->Type()) {
+              case eReflowType_StyleChanged:
+                 reflowReasonString = "incremental (StyleChanged)";
+              break;
+              case eReflowType_ReflowDirty:
+                 reflowReasonString = "incremental (ReflowDirty)";
+              break;
+              default:
+                 reflowReasonString = "incremental (Unknown)";
+            }
+        }                             
+        break;
+        default:
+          reflowReasonString = "unknown";
+          break;
+    }
+
+    printf("%s",reflowReasonString);
+}
+
+#endif
+#ifdef DEBUG_LAYOUT
+void
+nsFrame::GetBoxName(nsAutoString& aName)
+{
+  GetFrameName(aName);
+}
+#endif
+
+#ifdef DEBUG
+static void
+GetTagName(nsFrame* aFrame, nsIContent* aContent, int aResultSize,
+           char* aResult)
+{
+  if (aContent) {
+    snprintf(aResult, aResultSize, "%s@%p",
+             nsAtomCString(aContent->NodeInfo()->NameAtom()).get(), aFrame);
+  }
+  else {
+    snprintf(aResult, aResultSize, "@%p", aFrame);
+  }
+}
+
+void
+nsFrame::Trace(const char* aMethod, bool aEnter)
+{
+  if (NS_FRAME_LOG_TEST(sFrameLogModule, NS_FRAME_TRACE_CALLS)) {
+    char tagbuf[40];
+    GetTagName(this, mContent, sizeof(tagbuf), tagbuf);
+    PR_LogPrint("%s: %s %s", tagbuf, aEnter ? "enter" : "exit", aMethod);
+  }
+}
+
+void
+nsFrame::Trace(const char* aMethod, bool aEnter, nsReflowStatus aStatus)
+{
+  if (NS_FRAME_LOG_TEST(sFrameLogModule, NS_FRAME_TRACE_CALLS)) {
+    char tagbuf[40];
+    GetTagName(this, mContent, sizeof(tagbuf), tagbuf);
+    PR_LogPrint("%s: %s %s, status=%scomplete%s",
+                tagbuf, aEnter ? "enter" : "exit", aMethod,
+                NS_FRAME_IS_NOT_COMPLETE(aStatus) ? "not" : "",
+                (NS_FRAME_REFLOW_NEXTINFLOW & aStatus) ? "+reflow" : "");
+  }
+}
+
+void
+nsFrame::TraceMsg(const char* aFormatString, ...)
+{
+  if (NS_FRAME_LOG_TEST(sFrameLogModule, NS_FRAME_TRACE_CALLS)) {
+    // Format arguments into a buffer
+    char argbuf[200];
+    va_list ap;
+    va_start(ap, aFormatString);
+    PR_vsnprintf(argbuf, sizeof(argbuf), aFormatString, ap);
+    va_end(ap);
+
+    char tagbuf[40];
+    GetTagName(this, mContent, sizeof(tagbuf), tagbuf);
+    PR_LogPrint("%s: %s", tagbuf, argbuf);
+  }
+}
+
+void
+nsFrame::VerifyDirtyBitSet(const nsFrameList& aFrameList)
+{
+  for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
+    NS_ASSERTION(e.get()->GetStateBits() & NS_FRAME_IS_DIRTY,
+                 "dirty bit not set");
+  }
+}
+
+// Start Display Reflow
+#ifdef DEBUG
+
+DR_cookie::DR_cookie(nsPresContext*          aPresContext,
+                     nsIFrame*                aFrame, 
+                     const ReflowInput& aReflowInput,
+                     ReflowOutput&     aMetrics,
+                     nsReflowStatus&          aStatus)
+  :mPresContext(aPresContext), mFrame(aFrame), mReflowInput(aReflowInput), mMetrics(aMetrics), mStatus(aStatus)
+{
+  MOZ_COUNT_CTOR(DR_cookie);
+  mValue = nsFrame::DisplayReflowEnter(aPresContext, mFrame, mReflowInput);
+}
+
+DR_cookie::~DR_cookie()
+{
+  MOZ_COUNT_DTOR(DR_cookie);
+  nsFrame::DisplayReflowExit(mPresContext, mFrame, mMetrics, mStatus, mValue);
+}
+
+DR_layout_cookie::DR_layout_cookie(nsIFrame* aFrame)
+  : mFrame(aFrame)
+{
+  MOZ_COUNT_CTOR(DR_layout_cookie);
+  mValue = nsFrame::DisplayLayoutEnter(mFrame);
+}
+
+DR_layout_cookie::~DR_layout_cookie()
+{
+  MOZ_COUNT_DTOR(DR_layout_cookie);
+  nsFrame::DisplayLayoutExit(mFrame, mValue);
+}
+
+DR_intrinsic_width_cookie::DR_intrinsic_width_cookie(
+                     nsIFrame*                aFrame, 
+                     const char*              aType,
+                     nscoord&                 aResult)
+  : mFrame(aFrame)
+  , mType(aType)
+  , mResult(aResult)
+{
+  MOZ_COUNT_CTOR(DR_intrinsic_width_cookie);
+  mValue = nsFrame::DisplayIntrinsicISizeEnter(mFrame, mType);
+}
+
+DR_intrinsic_width_cookie::~DR_intrinsic_width_cookie()
+{
+  MOZ_COUNT_DTOR(DR_intrinsic_width_cookie);
+  nsFrame::DisplayIntrinsicISizeExit(mFrame, mType, mResult, mValue);
+}
+
+DR_intrinsic_size_cookie::DR_intrinsic_size_cookie(
+                     nsIFrame*                aFrame, 
+                     const char*              aType,
+                     nsSize&                  aResult)
+  : mFrame(aFrame)
+  , mType(aType)
+  , mResult(aResult)
+{
+  MOZ_COUNT_CTOR(DR_intrinsic_size_cookie);
+  mValue = nsFrame::DisplayIntrinsicSizeEnter(mFrame, mType);
+}
+
+DR_intrinsic_size_cookie::~DR_intrinsic_size_cookie()
+{
+  MOZ_COUNT_DTOR(DR_intrinsic_size_cookie);
+  nsFrame::DisplayIntrinsicSizeExit(mFrame, mType, mResult, mValue);
+}
+
+DR_init_constraints_cookie::DR_init_constraints_cookie(
+                     nsIFrame*                aFrame,
+                     ReflowInput*       aState,
+                     nscoord                  aCBWidth,
+                     nscoord                  aCBHeight,
+                     const nsMargin*          aMargin,
+                     const nsMargin*          aPadding)
+  : mFrame(aFrame)
+  , mState(aState)
+{
+  MOZ_COUNT_CTOR(DR_init_constraints_cookie);
+  mValue = ReflowInput::DisplayInitConstraintsEnter(mFrame, mState,
+                                                          aCBWidth, aCBHeight,
+                                                          aMargin, aPadding);
+}
+
+DR_init_constraints_cookie::~DR_init_constraints_cookie()
+{
+  MOZ_COUNT_DTOR(DR_init_constraints_cookie);
+  ReflowInput::DisplayInitConstraintsExit(mFrame, mState, mValue);
+}
+
+DR_init_offsets_cookie::DR_init_offsets_cookie(
+                     nsIFrame*                aFrame,
+                     SizeComputationInput*        aState,
+                     const LogicalSize&       aPercentBasis,
+                     const nsMargin*          aMargin,
+                     const nsMargin*          aPadding)
+  : mFrame(aFrame)
+  , mState(aState)
+{
+  MOZ_COUNT_CTOR(DR_init_offsets_cookie);
+  mValue = SizeComputationInput::DisplayInitOffsetsEnter(mFrame, mState,
+                                                     aPercentBasis,
+                                                     aMargin, aPadding);
+}
+
+DR_init_offsets_cookie::~DR_init_offsets_cookie()
+{
+  MOZ_COUNT_DTOR(DR_init_offsets_cookie);
+  SizeComputationInput::DisplayInitOffsetsExit(mFrame, mState, mValue);
+}
+
+DR_init_type_cookie::DR_init_type_cookie(
+                     nsIFrame*                aFrame,
+                     ReflowInput*       aState)
+  : mFrame(aFrame)
+  , mState(aState)
+{
+  MOZ_COUNT_CTOR(DR_init_type_cookie);
+  mValue = ReflowInput::DisplayInitFrameTypeEnter(mFrame, mState);
+}
+
+DR_init_type_cookie::~DR_init_type_cookie()
+{
+  MOZ_COUNT_DTOR(DR_init_type_cookie);
+  ReflowInput::DisplayInitFrameTypeExit(mFrame, mState, mValue);
+}
+
+struct DR_FrameTypeInfo;
+struct DR_FrameTreeNode;
+struct DR_Rule;
+
+struct DR_State
+{
+  DR_State();
+  ~DR_State();
+  void Init();
+  void AddFrameTypeInfo(nsIAtom* aFrameType,
+                        const char* aFrameNameAbbrev,
+                        const char* aFrameName);
+  DR_FrameTypeInfo* GetFrameTypeInfo(nsIAtom* aFrameType);
+  DR_FrameTypeInfo* GetFrameTypeInfo(char* aFrameName);
+  void InitFrameTypeTable();
+  DR_FrameTreeNode* CreateTreeNode(nsIFrame*                aFrame,
+                                   const ReflowInput* aReflowInput);
+  void FindMatchingRule(DR_FrameTreeNode& aNode);
+  bool RuleMatches(DR_Rule&          aRule,
+                     DR_FrameTreeNode& aNode);
+  bool GetToken(FILE* aFile,
+                  char* aBuf,
+                  size_t aBufSize);
+  DR_Rule* ParseRule(FILE* aFile);
+  void ParseRulesFile();
+  void AddRule(nsTArray<DR_Rule*>& aRules,
+               DR_Rule&            aRule);
+  bool IsWhiteSpace(int c);
+  bool GetNumber(char*    aBuf, 
+                 int32_t&  aNumber);
+  void PrettyUC(nscoord aSize,
+                char*   aBuf,
+                int     aBufSize);
+  void PrintMargin(const char* tag, const nsMargin* aMargin);
+  void DisplayFrameTypeInfo(nsIFrame* aFrame,
+                            int32_t   aIndent);
+  void DeleteTreeNode(DR_FrameTreeNode& aNode);
+
+  bool        mInited;
+  bool        mActive;
+  int32_t     mCount;
+  int32_t     mAssert;
+  int32_t     mIndent;
+  bool        mIndentUndisplayedFrames;
+  bool        mDisplayPixelErrors;
+  nsTArray<DR_Rule*>          mWildRules;
+  nsTArray<DR_FrameTypeInfo>  mFrameTypeTable;
+  // reflow specific state
+  nsTArray<DR_FrameTreeNode*> mFrameTreeLeaves;
+};
+
+static DR_State *DR_state; // the one and only DR_State
+
+struct DR_RulePart 
+{
+  explicit DR_RulePart(nsIAtom* aFrameType) : mFrameType(aFrameType), mNext(0) {}
+  void Destroy();
+
+  nsIAtom*     mFrameType;
+  DR_RulePart* mNext;
+};
+
+void DR_RulePart::Destroy()
+{
+  if (mNext) {
+    mNext->Destroy();
+  }
+  delete this;
+}
+
+struct DR_Rule 
+{
+  DR_Rule() : mLength(0), mTarget(nullptr), mDisplay(false) {
+    MOZ_COUNT_CTOR(DR_Rule);
+  }
+  ~DR_Rule() {
+    if (mTarget) mTarget->Destroy();
+    MOZ_COUNT_DTOR(DR_Rule);
+  }
+  void AddPart(nsIAtom* aFrameType);
+
+  uint32_t      mLength;
+  DR_RulePart*  mTarget;
+  bool          mDisplay;
+};
+
+void DR_Rule::AddPart(nsIAtom* aFrameType)
+{
+  DR_RulePart* newPart = new DR_RulePart(aFrameType);
+  newPart->mNext = mTarget;
+  mTarget = newPart;
+  mLength++;
+}
+
+struct DR_FrameTypeInfo
+{
+  DR_FrameTypeInfo(nsIAtom* aFrmeType, const char* aFrameNameAbbrev, const char* aFrameName);
+  ~DR_FrameTypeInfo() { 
+      int32_t numElements;
+      numElements = mRules.Length();
+      for (int32_t i = numElements - 1; i >= 0; i--) {
+        delete mRules.ElementAt(i);
+      }
+   }
+
+  nsIAtom*    mType;
+  char        mNameAbbrev[16];
+  char        mName[32];
+  nsTArray<DR_Rule*> mRules;
+private:
+  DR_FrameTypeInfo& operator=(const DR_FrameTypeInfo&) = delete;
+};
+
+DR_FrameTypeInfo::DR_FrameTypeInfo(nsIAtom* aFrameType, 
+                                   const char* aFrameNameAbbrev, 
+                                   const char* aFrameName)
+{
+  mType = aFrameType;
+  PL_strncpyz(mNameAbbrev, aFrameNameAbbrev, sizeof(mNameAbbrev));
+  PL_strncpyz(mName, aFrameName, sizeof(mName));
+}
+
+struct DR_FrameTreeNode
+{
+  DR_FrameTreeNode(nsIFrame* aFrame, DR_FrameTreeNode* aParent) : mFrame(aFrame), mParent(aParent), mDisplay(0), mIndent(0)
+  {
+    MOZ_COUNT_CTOR(DR_FrameTreeNode);
+  }
+
+  ~DR_FrameTreeNode()
+  {
+    MOZ_COUNT_DTOR(DR_FrameTreeNode);
+  }
+
+  nsIFrame*         mFrame;
+  DR_FrameTreeNode* mParent;
+  bool              mDisplay;
+  uint32_t          mIndent;
+};
+
+// DR_State implementation
+
+DR_State::DR_State() 
+: mInited(false), mActive(false), mCount(0), mAssert(-1), mIndent(0), 
+  mIndentUndisplayedFrames(false), mDisplayPixelErrors(false)
+{
+  MOZ_COUNT_CTOR(DR_State);
+}
+
+void DR_State::Init() 
+{
+  char* env = PR_GetEnv("GECKO_DISPLAY_REFLOW_ASSERT");
+  int32_t num;
+  if (env) {
+    if (GetNumber(env, num)) 
+      mAssert = num;
+    else 
+      printf("GECKO_DISPLAY_REFLOW_ASSERT - invalid value = %s", env);
+  }
+
+  env = PR_GetEnv("GECKO_DISPLAY_REFLOW_INDENT_START");
+  if (env) {
+    if (GetNumber(env, num)) 
+      mIndent = num;
+    else 
+      printf("GECKO_DISPLAY_REFLOW_INDENT_START - invalid value = %s", env);
+  }
+
+  env = PR_GetEnv("GECKO_DISPLAY_REFLOW_INDENT_UNDISPLAYED_FRAMES");
+  if (env) {
+    if (GetNumber(env, num)) 
+      mIndentUndisplayedFrames = num;
+    else 
+      printf("GECKO_DISPLAY_REFLOW_INDENT_UNDISPLAYED_FRAMES - invalid value = %s", env);
+  }
+
+  env = PR_GetEnv("GECKO_DISPLAY_REFLOW_FLAG_PIXEL_ERRORS");
+  if (env) {
+    if (GetNumber(env, num)) 
+      mDisplayPixelErrors = num;
+    else 
+      printf("GECKO_DISPLAY_REFLOW_FLAG_PIXEL_ERRORS - invalid value = %s", env);
+  }
+
+  InitFrameTypeTable();
+  ParseRulesFile();
+  mInited = true;
+}
+
+DR_State::~DR_State()
+{
+  MOZ_COUNT_DTOR(DR_State);
+  int32_t numElements, i;
+  numElements = mWildRules.Length();
+  for (i = numElements - 1; i >= 0; i--) {
+    delete mWildRules.ElementAt(i);
+  }
+  numElements = mFrameTreeLeaves.Length();
+  for (i = numElements - 1; i >= 0; i--) {
+    delete mFrameTreeLeaves.ElementAt(i);
+  }
+}
+
+bool DR_State::GetNumber(char*     aBuf, 
+                           int32_t&  aNumber)
+{
+  if (sscanf(aBuf, "%d", &aNumber) > 0) 
+    return true;
+  else 
+    return false;
+}
+
+bool DR_State::IsWhiteSpace(int c) {
+  return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r');
+}
+
+bool DR_State::GetToken(FILE* aFile,
+                          char* aBuf,
+                          size_t aBufSize)
+{
+  bool haveToken = false;
+  aBuf[0] = 0;
+  // get the 1st non whitespace char
+  int c = -1;
+  for (c = getc(aFile); (c > 0) && IsWhiteSpace(c); c = getc(aFile)) {
+  }
+
+  if (c > 0) {
+    haveToken = true;
+    aBuf[0] = c;
+    // get everything up to the next whitespace char
+    size_t cX;
+    for (cX = 1; cX + 1 < aBufSize ; cX++) {
+      c = getc(aFile);
+      if (c < 0) { // EOF
+        ungetc(' ', aFile); 
+        break;
+      }
+      else {
+        if (IsWhiteSpace(c)) {
+          break;
+        }
+        else {
+          aBuf[cX] = c;
+        }
+      }
+    }
+    aBuf[cX] = 0;
+  }
+  return haveToken;
+}
+
+DR_Rule* DR_State::ParseRule(FILE* aFile)
+{
+  char buf[128];
+  int32_t doDisplay;
+  DR_Rule* rule = nullptr;
+  while (GetToken(aFile, buf, sizeof(buf))) {
+    if (GetNumber(buf, doDisplay)) {
+      if (rule) { 
+        rule->mDisplay = !!doDisplay;
+        break;
+      }
+      else {
+        printf("unexpected token - %s \n", buf);
+      }
+    }
+    else {
+      if (!rule) {
+        rule = new DR_Rule;
+      }
+      if (strcmp(buf, "*") == 0) {
+        rule->AddPart(nullptr);
+      }
+      else {
+        DR_FrameTypeInfo* info = GetFrameTypeInfo(buf);
+        if (info) {
+          rule->AddPart(info->mType);
+        }
+        else {
+          printf("invalid frame type - %s \n", buf);
+        }
+      }
+    }
+  }
+  return rule;
+}
+
+void DR_State::AddRule(nsTArray<DR_Rule*>& aRules,
+                       DR_Rule&            aRule)
+{
+  int32_t numRules = aRules.Length();
+  for (int32_t ruleX = 0; ruleX < numRules; ruleX++) {
+    DR_Rule* rule = aRules.ElementAt(ruleX);
+    NS_ASSERTION(rule, "program error");
+    if (aRule.mLength > rule->mLength) {
+      aRules.InsertElementAt(ruleX, &aRule);
+      return;
+    }
+  }
+  aRules.AppendElement(&aRule);
+}
+
+void DR_State::ParseRulesFile()
+{
+  char* path = PR_GetEnv("GECKO_DISPLAY_REFLOW_RULES_FILE");
+  if (path) {
+    FILE* inFile = fopen(path, "r");
+    if (inFile) {
+      for (DR_Rule* rule = ParseRule(inFile); rule; rule = ParseRule(inFile)) {
+        if (rule->mTarget) {
+          nsIAtom* fType = rule->mTarget->mFrameType;
+          if (fType) {
+            DR_FrameTypeInfo* info = GetFrameTypeInfo(fType);
+            if (info) {
+              AddRule(info->mRules, *rule);
+            }
+          }
+          else {
+            AddRule(mWildRules, *rule);
+          }
+          mActive = true;
+        }
+      }
+
+      fclose(inFile);
+    }
+  }
+}
+
+
+void DR_State::AddFrameTypeInfo(nsIAtom* aFrameType,
+                                const char* aFrameNameAbbrev,
+                                const char* aFrameName)
+{
+  mFrameTypeTable.AppendElement(DR_FrameTypeInfo(aFrameType, aFrameNameAbbrev, aFrameName));
+}
+
+DR_FrameTypeInfo* DR_State::GetFrameTypeInfo(nsIAtom* aFrameType)
+{
+  int32_t numEntries = mFrameTypeTable.Length();
+  NS_ASSERTION(numEntries != 0, "empty FrameTypeTable");
+  for (int32_t i = 0; i < numEntries; i++) {
+    DR_FrameTypeInfo& info = mFrameTypeTable.ElementAt(i);
+    if (info.mType == aFrameType) {
+      return &info;
+    }
+  }
+  return &mFrameTypeTable.ElementAt(numEntries - 1); // return unknown frame type
+}
+
+DR_FrameTypeInfo* DR_State::GetFrameTypeInfo(char* aFrameName)
+{
+  int32_t numEntries = mFrameTypeTable.Length();
+  NS_ASSERTION(numEntries != 0, "empty FrameTypeTable");
+  for (int32_t i = 0; i < numEntries; i++) {
+    DR_FrameTypeInfo& info = mFrameTypeTable.ElementAt(i);
+    if ((strcmp(aFrameName, info.mName) == 0) || (strcmp(aFrameName, info.mNameAbbrev) == 0)) {
+      return &info;
+    }
+  }
+  return &mFrameTypeTable.ElementAt(numEntries - 1); // return unknown frame type
+}
+
+void DR_State::InitFrameTypeTable()
+{  
+  AddFrameTypeInfo(nsGkAtoms::blockFrame,            "block",     "block");
+  AddFrameTypeInfo(nsGkAtoms::brFrame,               "br",        "br");
+  AddFrameTypeInfo(nsGkAtoms::bulletFrame,           "bullet",    "bullet");
+  AddFrameTypeInfo(nsGkAtoms::colorControlFrame,     "color",     "colorControl");
+  AddFrameTypeInfo(nsGkAtoms::gfxButtonControlFrame, "button",    "gfxButtonControl");
+  AddFrameTypeInfo(nsGkAtoms::HTMLButtonControlFrame, "HTMLbutton",    "HTMLButtonControl");
+  AddFrameTypeInfo(nsGkAtoms::HTMLCanvasFrame,       "HTMLCanvas","HTMLCanvas");
+  AddFrameTypeInfo(nsGkAtoms::subDocumentFrame,      "subdoc",    "subDocument");
+  AddFrameTypeInfo(nsGkAtoms::imageFrame,            "img",       "image");
+  AddFrameTypeInfo(nsGkAtoms::inlineFrame,           "inline",    "inline");
+  AddFrameTypeInfo(nsGkAtoms::letterFrame,           "letter",    "letter");
+  AddFrameTypeInfo(nsGkAtoms::lineFrame,             "line",      "line");
+  AddFrameTypeInfo(nsGkAtoms::listControlFrame,      "select",    "select");
+  AddFrameTypeInfo(nsGkAtoms::objectFrame,           "obj",       "object");
+  AddFrameTypeInfo(nsGkAtoms::pageFrame,             "page",      "page");
+  AddFrameTypeInfo(nsGkAtoms::placeholderFrame,      "place",     "placeholder");
+  AddFrameTypeInfo(nsGkAtoms::canvasFrame,           "canvas",    "canvas");
+  AddFrameTypeInfo(nsGkAtoms::rootFrame,             "root",      "root");
+  AddFrameTypeInfo(nsGkAtoms::scrollFrame,           "scroll",    "scroll");
+  AddFrameTypeInfo(nsGkAtoms::tableCellFrame,        "cell",      "tableCell");
+  AddFrameTypeInfo(nsGkAtoms::bcTableCellFrame,      "bcCell",    "bcTableCell");
+  AddFrameTypeInfo(nsGkAtoms::tableColFrame,         "col",       "tableCol");
+  AddFrameTypeInfo(nsGkAtoms::tableColGroupFrame,    "colG",      "tableColGroup");
+  AddFrameTypeInfo(nsGkAtoms::tableFrame,            "tbl",       "table");
+  AddFrameTypeInfo(nsGkAtoms::tableWrapperFrame,     "tblW",      "tableWrapper");
+  AddFrameTypeInfo(nsGkAtoms::tableRowGroupFrame,    "rowG",      "tableRowGroup");
+  AddFrameTypeInfo(nsGkAtoms::tableRowFrame,         "row",       "tableRow");
+  AddFrameTypeInfo(nsGkAtoms::textInputFrame,        "textCtl",   "textInput");
+  AddFrameTypeInfo(nsGkAtoms::textFrame,             "text",      "text");
+  AddFrameTypeInfo(nsGkAtoms::viewportFrame,         "VP",        "viewport");
+#ifdef MOZ_XUL
+  AddFrameTypeInfo(nsGkAtoms::XULLabelFrame,         "XULLabel",  "XULLabel");
+  AddFrameTypeInfo(nsGkAtoms::boxFrame,              "Box",       "Box");
+  AddFrameTypeInfo(nsGkAtoms::sliderFrame,           "Slider",    "Slider");
+  AddFrameTypeInfo(nsGkAtoms::popupSetFrame,         "PopupSet",  "PopupSet");
+#endif
+  AddFrameTypeInfo(nullptr,                          "unknown",   "unknown");
+}
+
+
+void DR_State::DisplayFrameTypeInfo(nsIFrame* aFrame,
+                                    int32_t   aIndent)
+{ 
+  DR_FrameTypeInfo* frameTypeInfo = GetFrameTypeInfo(aFrame->GetType());
+  if (frameTypeInfo) {
+    for (int32_t i = 0; i < aIndent; i++) {
+      printf(" ");
+    }
+    if(!strcmp(frameTypeInfo->mNameAbbrev, "unknown")) {
+      if (aFrame) {
+       nsAutoString  name;
+       aFrame->GetFrameName(name);
+       printf("%s %p ", NS_LossyConvertUTF16toASCII(name).get(), (void*)aFrame);
+      }
+      else {
+        printf("%s %p ", frameTypeInfo->mNameAbbrev, (void*)aFrame);
+      }
+    }
+    else {
+      printf("%s %p ", frameTypeInfo->mNameAbbrev, (void*)aFrame);
+    }
+  }
+}
+
+bool DR_State::RuleMatches(DR_Rule&          aRule,
+                             DR_FrameTreeNode& aNode)
+{
+  NS_ASSERTION(aRule.mTarget, "program error");
+
+  DR_RulePart* rulePart;
+  DR_FrameTreeNode* parentNode;
+  for (rulePart = aRule.mTarget->mNext, parentNode = aNode.mParent;
+       rulePart && parentNode;
+       rulePart = rulePart->mNext, parentNode = parentNode->mParent) {
+    if (rulePart->mFrameType) {
+      if (parentNode->mFrame) {
+        if (rulePart->mFrameType != parentNode->mFrame->GetType()) {
+          return false;
+        }
+      }
+      else NS_ASSERTION(false, "program error");
+    }
+    // else wild card match
+  }
+  return true;
+}
+
+void DR_State::FindMatchingRule(DR_FrameTreeNode& aNode)
+{
+  if (!aNode.mFrame) {
+    NS_ASSERTION(false, "invalid DR_FrameTreeNode \n");
+    return;
+  }
+
+  bool matchingRule = false;
+
+  DR_FrameTypeInfo* info = GetFrameTypeInfo(aNode.mFrame->GetType());
+  NS_ASSERTION(info, "program error");
+  int32_t numRules = info->mRules.Length();
+  for (int32_t ruleX = 0; ruleX < numRules; ruleX++) {
+    DR_Rule* rule = info->mRules.ElementAt(ruleX);
+    if (rule && RuleMatches(*rule, aNode)) {
+      aNode.mDisplay = rule->mDisplay;
+      matchingRule = true;
+      break;
+    }
+  }
+  if (!matchingRule) {
+    int32_t numWildRules = mWildRules.Length();
+    for (int32_t ruleX = 0; ruleX < numWildRules; ruleX++) {
+      DR_Rule* rule = mWildRules.ElementAt(ruleX);
+      if (rule && RuleMatches(*rule, aNode)) {
+        aNode.mDisplay = rule->mDisplay;
+        break;
+      }
+    }
+  }
+}
+    
+DR_FrameTreeNode* DR_State::CreateTreeNode(nsIFrame*                aFrame,
+                                           const ReflowInput* aReflowInput)
+{
+  // find the frame of the parent reflow state (usually just the parent of aFrame)
+  nsIFrame* parentFrame;
+  if (aReflowInput) {
+    const ReflowInput* parentRI = aReflowInput->mParentReflowInput;
+    parentFrame = (parentRI) ? parentRI->mFrame : nullptr;
+  } else {
+    parentFrame = aFrame->GetParent();
+  }
+
+  // find the parent tree node leaf
+  DR_FrameTreeNode* parentNode = nullptr;
+  
+  DR_FrameTreeNode* lastLeaf = nullptr;
+  if(mFrameTreeLeaves.Length())
+    lastLeaf = mFrameTreeLeaves.ElementAt(mFrameTreeLeaves.Length() - 1);
+  if (lastLeaf) {
+    for (parentNode = lastLeaf; parentNode && (parentNode->mFrame != parentFrame); parentNode = parentNode->mParent) {
+    }
+  }
+  DR_FrameTreeNode* newNode = new DR_FrameTreeNode(aFrame, parentNode);
+  FindMatchingRule(*newNode);
+
+  newNode->mIndent = mIndent;
+  if (newNode->mDisplay || mIndentUndisplayedFrames) {
+    ++mIndent;
+  }
+
+  if (lastLeaf && (lastLeaf == parentNode)) {
+    mFrameTreeLeaves.RemoveElementAt(mFrameTreeLeaves.Length() - 1);
+  }
+  mFrameTreeLeaves.AppendElement(newNode);
+  mCount++;
+
+  return newNode;
+}
+
+void DR_State::PrettyUC(nscoord aSize,
+                        char*   aBuf,
+                        int     aBufSize)
+{
+  if (NS_UNCONSTRAINEDSIZE == aSize) {
+    strcpy(aBuf, "UC");
+  }
+  else {
+    if ((nscoord)0xdeadbeefU == aSize)
+    {
+      strcpy(aBuf, "deadbeef");
+    }
+    else {
+      snprintf(aBuf, aBufSize, "%d", aSize);
+    }
+  }
+}
+
+void DR_State::PrintMargin(const char *tag, const nsMargin* aMargin)
+{
+  if (aMargin) {
+    char t[16], r[16], b[16], l[16];
+    PrettyUC(aMargin->top, t, 16);
+    PrettyUC(aMargin->right, r, 16);
+    PrettyUC(aMargin->bottom, b, 16);
+    PrettyUC(aMargin->left, l, 16);
+    printf(" %s=%s,%s,%s,%s", tag, t, r, b, l);
+  } else {
+    // use %p here for consistency with other null-pointer printouts
+    printf(" %s=%p", tag, (void*)aMargin);
+  }
+}
+
+void DR_State::DeleteTreeNode(DR_FrameTreeNode& aNode)
+{
+  mFrameTreeLeaves.RemoveElement(&aNode);
+  int32_t numLeaves = mFrameTreeLeaves.Length();
+  if ((0 == numLeaves) || (aNode.mParent != mFrameTreeLeaves.ElementAt(numLeaves - 1))) {
+    mFrameTreeLeaves.AppendElement(aNode.mParent);
+  }
+
+  if (aNode.mDisplay || mIndentUndisplayedFrames) {
+    --mIndent;
+  }
+  // delete the tree node 
+  delete &aNode;
+}
+
+static void
+CheckPixelError(nscoord aSize,
+                int32_t aPixelToTwips)
+{
+  if (NS_UNCONSTRAINEDSIZE != aSize) {
+    if ((aSize % aPixelToTwips) > 0) {
+      printf("VALUE %d is not a whole pixel \n", aSize);
+    }
+  }
+}
+
+static void DisplayReflowEnterPrint(nsPresContext*          aPresContext,
+                                    nsIFrame*                aFrame,
+                                    const ReflowInput& aReflowInput,
+                                    DR_FrameTreeNode&        aTreeNode,
+                                    bool                     aChanged)
+{
+  if (aTreeNode.mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, aTreeNode.mIndent);
+
+    char width[16];
+    char height[16];
+
+    DR_state->PrettyUC(aReflowInput.AvailableWidth(), width, 16);
+    DR_state->PrettyUC(aReflowInput.AvailableHeight(), height, 16);
+    printf("Reflow a=%s,%s ", width, height);
+
+    DR_state->PrettyUC(aReflowInput.ComputedWidth(), width, 16);
+    DR_state->PrettyUC(aReflowInput.ComputedHeight(), height, 16);
+    printf("c=%s,%s ", width, height);
+
+    if (aFrame->GetStateBits() & NS_FRAME_IS_DIRTY)
+      printf("dirty ");
+
+    if (aFrame->GetStateBits() & NS_FRAME_HAS_DIRTY_CHILDREN)
+      printf("dirty-children ");
+
+    if (aReflowInput.mFlags.mSpecialBSizeReflow)
+      printf("special-bsize ");
+
+    if (aReflowInput.IsHResize())
+      printf("h-resize ");
+
+    if (aReflowInput.IsVResize())
+      printf("v-resize ");
+
+    nsIFrame* inFlow = aFrame->GetPrevInFlow();
+    if (inFlow) {
+      printf("pif=%p ", (void*)inFlow);
+    }
+    inFlow = aFrame->GetNextInFlow();
+    if (inFlow) {
+      printf("nif=%p ", (void*)inFlow);
+    }
+    if (aChanged) 
+      printf("CHANGED \n");
+    else 
+      printf("cnt=%d \n", DR_state->mCount);
+    if (DR_state->mDisplayPixelErrors) {
+      int32_t p2t = aPresContext->AppUnitsPerDevPixel();
+      CheckPixelError(aReflowInput.AvailableWidth(), p2t);
+      CheckPixelError(aReflowInput.AvailableHeight(), p2t);
+      CheckPixelError(aReflowInput.ComputedWidth(), p2t);
+      CheckPixelError(aReflowInput.ComputedHeight(), p2t);
+    }
+  }
+}
+
+void* nsFrame::DisplayReflowEnter(nsPresContext*          aPresContext,
+                                  nsIFrame*                aFrame,
+                                  const ReflowInput& aReflowInput)
+{
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  NS_ASSERTION(aFrame, "invalid call");
+
+  DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, &aReflowInput);
+  if (treeNode) {
+    DisplayReflowEnterPrint(aPresContext, aFrame, aReflowInput, *treeNode, false);
+  }
+  return treeNode;
+}
+
+void* nsFrame::DisplayLayoutEnter(nsIFrame* aFrame)
+{
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  NS_ASSERTION(aFrame, "invalid call");
+
+  DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr);
+  if (treeNode && treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    printf("XULLayout\n");
+  }
+  return treeNode;
+}
+
+void* nsFrame::DisplayIntrinsicISizeEnter(nsIFrame* aFrame,
+                                          const char* aType)
+{
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  NS_ASSERTION(aFrame, "invalid call");
+
+  DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr);
+  if (treeNode && treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    printf("Get%sWidth\n", aType);
+  }
+  return treeNode;
+}
+
+void* nsFrame::DisplayIntrinsicSizeEnter(nsIFrame* aFrame,
+                                         const char* aType)
+{
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  NS_ASSERTION(aFrame, "invalid call");
+
+  DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr);
+  if (treeNode && treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    printf("Get%sSize\n", aType);
+  }
+  return treeNode;
+}
+
+void nsFrame::DisplayReflowExit(nsPresContext*      aPresContext,
+                                nsIFrame*            aFrame,
+                                ReflowOutput& aMetrics,
+                                nsReflowStatus       aStatus,
+                                void*                aFrameTreeNode)
+{
+  if (!DR_state->mActive) return;
+
+  NS_ASSERTION(aFrame, "DisplayReflowExit - invalid call");
+  if (!aFrameTreeNode) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+
+    char width[16];
+    char height[16];
+    char x[16];
+    char y[16];
+    DR_state->PrettyUC(aMetrics.Width(), width, 16);
+    DR_state->PrettyUC(aMetrics.Height(), height, 16);
+    printf("Reflow d=%s,%s", width, height);
+
+    if (!NS_FRAME_IS_FULLY_COMPLETE(aStatus)) {
+      printf(" status=0x%x", aStatus);
+    }
+    if (aFrame->HasOverflowAreas()) {
+      DR_state->PrettyUC(aMetrics.VisualOverflow().x, x, 16);
+      DR_state->PrettyUC(aMetrics.VisualOverflow().y, y, 16);
+      DR_state->PrettyUC(aMetrics.VisualOverflow().width, width, 16);
+      DR_state->PrettyUC(aMetrics.VisualOverflow().height, height, 16);
+      printf(" vis-o=(%s,%s) %s x %s", x, y, width, height);
+
+      nsRect storedOverflow = aFrame->GetVisualOverflowRect();
+      DR_state->PrettyUC(storedOverflow.x, x, 16);
+      DR_state->PrettyUC(storedOverflow.y, y, 16);
+      DR_state->PrettyUC(storedOverflow.width, width, 16);
+      DR_state->PrettyUC(storedOverflow.height, height, 16);
+      printf(" vis-sto=(%s,%s) %s x %s", x, y, width, height);
+
+      DR_state->PrettyUC(aMetrics.ScrollableOverflow().x, x, 16);
+      DR_state->PrettyUC(aMetrics.ScrollableOverflow().y, y, 16);
+      DR_state->PrettyUC(aMetrics.ScrollableOverflow().width, width, 16);
+      DR_state->PrettyUC(aMetrics.ScrollableOverflow().height, height, 16);
+      printf(" scr-o=(%s,%s) %s x %s", x, y, width, height);
+
+      storedOverflow = aFrame->GetScrollableOverflowRect();
+      DR_state->PrettyUC(storedOverflow.x, x, 16);
+      DR_state->PrettyUC(storedOverflow.y, y, 16);
+      DR_state->PrettyUC(storedOverflow.width, width, 16);
+      DR_state->PrettyUC(storedOverflow.height, height, 16);
+      printf(" scr-sto=(%s,%s) %s x %s", x, y, width, height);
+    }
+    printf("\n");
+    if (DR_state->mDisplayPixelErrors) {
+      int32_t p2t = aPresContext->AppUnitsPerDevPixel();
+      CheckPixelError(aMetrics.Width(), p2t);
+      CheckPixelError(aMetrics.Height(), p2t);
+    }
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+void nsFrame::DisplayLayoutExit(nsIFrame*            aFrame,
+                                void*                aFrameTreeNode)
+{
+  if (!DR_state->mActive) return;
+
+  NS_ASSERTION(aFrame, "non-null frame required");
+  if (!aFrameTreeNode) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    nsRect rect = aFrame->GetRect();
+    printf("XULLayout=%d,%d,%d,%d\n", rect.x, rect.y, rect.width, rect.height);
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+void nsFrame::DisplayIntrinsicISizeExit(nsIFrame*            aFrame,
+                                        const char*          aType,
+                                        nscoord              aResult,
+                                        void*                aFrameTreeNode)
+{
+  if (!DR_state->mActive) return;
+
+  NS_ASSERTION(aFrame, "non-null frame required");
+  if (!aFrameTreeNode) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    char width[16];
+    DR_state->PrettyUC(aResult, width, 16);
+    printf("Get%sWidth=%s\n", aType, width);
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+void nsFrame::DisplayIntrinsicSizeExit(nsIFrame*            aFrame,
+                                       const char*          aType,
+                                       nsSize               aResult,
+                                       void*                aFrameTreeNode)
+{
+  if (!DR_state->mActive) return;
+
+  NS_ASSERTION(aFrame, "non-null frame required");
+  if (!aFrameTreeNode) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+
+    char width[16];
+    char height[16];
+    DR_state->PrettyUC(aResult.width, width, 16);
+    DR_state->PrettyUC(aResult.height, height, 16);
+    printf("Get%sSize=%s,%s\n", aType, width, height);
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+/* static */ void
+nsFrame::DisplayReflowStartup()
+{
+  DR_state = new DR_State();
+}
+
+/* static */ void
+nsFrame::DisplayReflowShutdown()
+{
+  delete DR_state;
+  DR_state = nullptr;
+}
+
+void DR_cookie::Change() const
+{
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)mValue;
+  if (treeNode && treeNode->mDisplay) {
+    DisplayReflowEnterPrint(mPresContext, mFrame, mReflowInput, *treeNode, true);
+  }
+}
+
+/* static */ void*
+ReflowInput::DisplayInitConstraintsEnter(nsIFrame* aFrame,
+                                               ReflowInput* aState,
+                                               nscoord aContainingBlockWidth,
+                                               nscoord aContainingBlockHeight,
+                                               const nsMargin* aBorder,
+                                               const nsMargin* aPadding)
+{
+  NS_PRECONDITION(aFrame, "non-null frame required");
+  NS_PRECONDITION(aState, "non-null state required");
+
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, aState);
+  if (treeNode && treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+
+    printf("InitConstraints parent=%p",
+           (void*)aState->mParentReflowInput);
+
+    char width[16];
+    char height[16];
+
+    DR_state->PrettyUC(aContainingBlockWidth, width, 16);
+    DR_state->PrettyUC(aContainingBlockHeight, height, 16);
+    printf(" cb=%s,%s", width, height);
+
+    DR_state->PrettyUC(aState->AvailableWidth(), width, 16);
+    DR_state->PrettyUC(aState->AvailableHeight(), height, 16);
+    printf(" as=%s,%s", width, height);
+
+    DR_state->PrintMargin("b", aBorder);
+    DR_state->PrintMargin("p", aPadding);
+    putchar('\n');
+  }
+  return treeNode;
+}
+
+/* static */ void
+ReflowInput::DisplayInitConstraintsExit(nsIFrame* aFrame,
+                                              ReflowInput* aState,
+                                              void* aValue)
+{
+  NS_PRECONDITION(aFrame, "non-null frame required");
+  NS_PRECONDITION(aState, "non-null state required");
+
+  if (!DR_state->mActive) return;
+  if (!aValue) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    char cmiw[16], cw[16], cmxw[16], cmih[16], ch[16], cmxh[16];
+    DR_state->PrettyUC(aState->ComputedMinWidth(), cmiw, 16);
+    DR_state->PrettyUC(aState->ComputedWidth(), cw, 16);
+    DR_state->PrettyUC(aState->ComputedMaxWidth(), cmxw, 16);
+    DR_state->PrettyUC(aState->ComputedMinHeight(), cmih, 16);
+    DR_state->PrettyUC(aState->ComputedHeight(), ch, 16);
+    DR_state->PrettyUC(aState->ComputedMaxHeight(), cmxh, 16);
+    printf("InitConstraints= cw=(%s <= %s <= %s) ch=(%s <= %s <= %s)",
+           cmiw, cw, cmxw, cmih, ch, cmxh);
+    DR_state->PrintMargin("co", &aState->ComputedPhysicalOffsets());
+    putchar('\n');
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+
+/* static */ void*
+SizeComputationInput::DisplayInitOffsetsEnter(nsIFrame* aFrame,
+                                          SizeComputationInput* aState,
+                                          const LogicalSize& aPercentBasis,
+                                          const nsMargin* aBorder,
+                                          const nsMargin* aPadding)
+{
+  NS_PRECONDITION(aFrame, "non-null frame required");
+  NS_PRECONDITION(aState, "non-null state required");
+
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  // aState is not necessarily a ReflowInput
+  DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr);
+  if (treeNode && treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+
+    char horizPctBasisStr[16];
+    char vertPctBasisStr[16];
+    WritingMode wm = aState->GetWritingMode();
+    DR_state->PrettyUC(aPercentBasis.ISize(wm), horizPctBasisStr, 16);
+    DR_state->PrettyUC(aPercentBasis.BSize(wm), vertPctBasisStr, 16);
+    printf("InitOffsets pct_basis=%s,%s", horizPctBasisStr, vertPctBasisStr);
+
+    DR_state->PrintMargin("b", aBorder);
+    DR_state->PrintMargin("p", aPadding);
+    putchar('\n');
+  }
+  return treeNode;
+}
+
+/* static */ void
+SizeComputationInput::DisplayInitOffsetsExit(nsIFrame* aFrame,
+                                         SizeComputationInput* aState,
+                                         void* aValue)
+{
+  NS_PRECONDITION(aFrame, "non-null frame required");
+  NS_PRECONDITION(aState, "non-null state required");
+
+  if (!DR_state->mActive) return;
+  if (!aValue) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    printf("InitOffsets=");
+    DR_state->PrintMargin("m", &aState->ComputedPhysicalMargin());
+    DR_state->PrintMargin("p", &aState->ComputedPhysicalPadding());
+    DR_state->PrintMargin("p+b", &aState->ComputedPhysicalBorderPadding());
+    putchar('\n');
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+/* static */ void*
+ReflowInput::DisplayInitFrameTypeEnter(nsIFrame* aFrame,
+                                             ReflowInput* aState)
+{
+  NS_PRECONDITION(aFrame, "non-null frame required");
+  NS_PRECONDITION(aState, "non-null state required");
+
+  if (!DR_state->mInited) DR_state->Init();
+  if (!DR_state->mActive) return nullptr;
+
+  // we don't print anything here
+  return DR_state->CreateTreeNode(aFrame, aState);
+}
+
+/* static */ void
+ReflowInput::DisplayInitFrameTypeExit(nsIFrame* aFrame,
+                                            ReflowInput* aState,
+                                            void* aValue)
+{
+  NS_PRECONDITION(aFrame, "non-null frame required");
+  NS_PRECONDITION(aState, "non-null state required");
+
+  if (!DR_state->mActive) return;
+  if (!aValue) return;
+
+  DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue;
+  if (treeNode->mDisplay) {
+    DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent);
+    printf("InitFrameType");
+
+    const nsStyleDisplay *disp = aState->mStyleDisplay;
+
+    if (aFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)
+      printf(" out-of-flow");
+    if (aFrame->GetPrevInFlow())
+      printf(" prev-in-flow");
+    if (aFrame->IsAbsolutelyPositioned())
+      printf(" abspos");
+    if (aFrame->IsFloating())
+      printf(" float");
+
+    // This array must exactly match the StyleDisplay enum.
+    const char *const displayTypes[] = {
+      "none", "block", "inline", "inline-block", "list-item", "table",
+      "inline-table", "table-row-group", "table-column", "table-column",
+      "table-column-group", "table-header-group", "table-footer-group",
+      "table-row", "table-cell", "table-caption", "flex", "inline-flex",
+      "grid", "inline-grid", "ruby", "ruby-base", "ruby-base-container",
+      "ruby-text", "ruby-text-container", "contents", "-webkit-box",
+      "-webkit-inline-box", "box", "inline-box",
+#ifdef MOZ_XUL
+      "grid", "inline-grid", "grid-group", "grid-line", "stack",
+      "inline-stack", "deck", "groupbox", "popup",
+#endif
+    };
+    const uint32_t display = static_cast<uint32_t>(disp->mDisplay);
+    if (display >= ArrayLength(displayTypes))
+      printf(" display=%u", display);
+    else
+      printf(" display=%s", displayTypes[display]);
+
+    // This array must exactly match the NS_CSS_FRAME_TYPE constants.
+    const char *const cssFrameTypes[] = {
+      "unknown", "inline", "block", "floating", "absolute", "internal-table"
+    };
+    nsCSSFrameType bareType = NS_FRAME_GET_TYPE(aState->mFrameType);
+    bool repNoBlock = NS_FRAME_IS_REPLACED_NOBLOCK(aState->mFrameType);
+    bool repBlock = NS_FRAME_IS_REPLACED_CONTAINS_BLOCK(aState->mFrameType);
+
+    if (bareType >= ArrayLength(cssFrameTypes)) {
+      printf(" result=type %u", bareType);
+    } else {
+      printf(" result=%s", cssFrameTypes[bareType]);
+    }
+    printf("%s%s\n", repNoBlock ? " +rep" : "", repBlock ? " +repBlk" : "");
+  }
+  DR_state->DeleteTreeNode(*treeNode);
+}
+
+#endif
+// End Display Reflow
+
+#endif