Attachment 8498189 Details for Bug 907396

[patch] part 1 of the Fctor changes - the InsertionPoint refactoring (idempotent)

907396-display-contents-Fctor-XBL-refactor (text/plain), 58.35 KB, created by Mats Palmgren (inactive)

(hide)

Description:

Filename:

MIME Type:

Creator: Mats Palmgren (inactive)

Size: 58.35 KB

patch

obsolete

># HG changeset patch
># Parent fed3ec86f7ef2d117346c89dab4e1277de1e809b
># User Mats Palmgren <mats@mozilla.com>
>Bug 907396 - Replace aParentFrame/aContainer with a POD struct (InsertionPoint) in a bunch of places, to prepare for display:contents fixes for XBL and shadow DOM trees.  r=bzbarsky
>
>diff --git a/layout/base/nsCSSFrameConstructor.cpp b/layout/base/nsCSSFrameConstructor.cpp
>--- a/layout/base/nsCSSFrameConstructor.cpp
>+++ b/layout/base/nsCSSFrameConstructor.cpp
>@@ -3978,16 +3978,17 @@ nsCSSFrameConstructor::CreateAnonymousFr
>   } else {
>     ancestorPusher.PushStyleScope(aParent->AsElement());
>   }
> 
>   nsIAnonymousContentCreator* creator = do_QueryFrame(aParentFrame);
>   NS_ASSERTION(creator,
>                "How can that happen if we have nodes to construct frames for?");
> 
>+  InsertionPoint insertion(aParentFrame, aParent);
>   for (uint32_t i=0; i < count; i++) {
>     nsIContent* content = newAnonymousItems[i].mContent;
>     NS_ASSERTION(content, "null anonymous content?");
>     NS_ASSERTION(!newAnonymousItems[i].mStyleContext, "Unexpected style context");
>     NS_ASSERTION(newAnonymousItems[i].mChildren.IsEmpty(),
>                  "This method is not currently used with frames that implement "
>                  "nsIAnonymousContentCreator::CreateAnonymousContent to "
>                  "output a list where the items have their own children");
>@@ -4001,17 +4002,17 @@ nsCSSFrameConstructor::CreateAnonymousFr
>     } else {
>       FrameConstructionItemList items;
>       {
>         // Skip parent display based style-fixup during our 
>         // AddFrameConstructionItems() call:
>         TreeMatchContext::AutoParentDisplayBasedStyleFixupSkipper
>           parentDisplayBasedStyleFixupSkipper(aState.mTreeMatchContext);
> 
>-        AddFrameConstructionItems(aState, content, true, aParentFrame, items);
>+        AddFrameConstructionItems(aState, content, true, insertion, items);
>       }
>       ConstructFramesFromItemList(aState, items, aParentFrame, aChildItems);
>     }
>   }
> 
>   return NS_OK;
> }
> 
>@@ -4751,37 +4752,55 @@ nsCSSFrameConstructor::InitAndRestoreFra
>   if (aAllowCounters &&
>       mCounterManager.AddCounterResetsAndIncrements(aNewFrame)) {
>     CountersDirty();
>   }
> }
> 
> already_AddRefed<nsStyleContext>
> nsCSSFrameConstructor::ResolveStyleContext(nsIFrame*         aParentFrame,
>-                                           nsIContent*       aContent,
>+                                           nsIContent*       aContainer,
>+                                           nsIContent*       aChild,
>                                            nsFrameConstructorState* aState)
> {
>   nsStyleContext* parentStyleContext = nullptr;
>-  NS_ASSERTION(aContent->GetParent(), "Must have parent here");
>+  NS_ASSERTION(aChild->GetParent(), "Must have parent here");
> 
>   aParentFrame = nsFrame::CorrectStyleParentFrame(aParentFrame, nullptr);
> 
>   if (aParentFrame) {
>     // Resolve the style context based on the content object and the parent
>     // style context
>     parentStyleContext = aParentFrame->StyleContext();
>   } else {
>     // Perhaps aParentFrame is a canvasFrame and we're replicating
>     // fixed-pos frames.
>     // XXX should we create a way to tell ConstructFrame which style
>     // context to use, and pass it the style context for the
>     // previous page's fixed-pos frame?
>   }
> 
>-  return ResolveStyleContext(parentStyleContext, aContent, aState);
>+  return ResolveStyleContext(parentStyleContext, aChild, aState);
>+}
>+
>+already_AddRefed<nsStyleContext>
>+nsCSSFrameConstructor::ResolveStyleContext(nsIFrame*          aParentFrame,
>+                                           nsIContent*              aChild,
>+                                           nsFrameConstructorState* aState)
>+{
>+  return ResolveStyleContext(aParentFrame, aChild->GetParent(), aChild, aState);
>+}
>+
>+already_AddRefed<nsStyleContext>
>+nsCSSFrameConstructor::ResolveStyleContext(const InsertionPoint&    aInsertion,
>+                                           nsIContent*              aChild,
>+                                           nsFrameConstructorState* aState)
>+{
>+  return ResolveStyleContext(aInsertion.mParentFrame, aInsertion.mContainer,
>+                             aChild, aState);
> }
> 
> already_AddRefed<nsStyleContext>
> nsCSSFrameConstructor::ResolveStyleContext(nsStyleContext* aParentStyleContext,
>                                            nsIContent* aContent,
>                                            nsFrameConstructorState* aState)
> {
>   nsStyleSet *styleSet = mPresShell->StyleSet();
>@@ -5293,17 +5312,17 @@ nsCSSFrameConstructor::AddPageBreakItem(
>                     kNameSpaceID_None, nullptr, pseudoStyle.forget(),
>                     true, nullptr);
> }
> 
> void
> nsCSSFrameConstructor::AddFrameConstructionItems(nsFrameConstructorState& aState,
>                                                  nsIContent* aContent,
>                                                  bool aSuppressWhiteSpaceOptimizations,
>-                                                 nsContainerFrame* aParentFrame,
>+                                                 const InsertionPoint& aInsertion,
>                                                  FrameConstructionItemList& aItems)
> {
>   aContent->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);
>   if (aContent->IsElement()) {
>     // We can't just remove our pending restyle flags, since we may
>     // have restyle-later-siblings set on us.  But we _can_ remove the
>     // "is possible restyle root" flags, and need to.  Otherwise we can
>     // end up with stale such flags (e.g. if we used to have a
>@@ -5319,16 +5338,17 @@ nsCSSFrameConstructor::AddFrameConstruct
>       aContent->GetPrimaryFrame()->GetContent() == aContent &&
>       !aState.mCreatingExtraFrames) {
>     NS_ERROR("asked to create frame construction item for a node that already "
>              "has a frame");
>     return;
>   }
> 
>   // don't create a whitespace frame if aParent doesn't want it
>+  nsContainerFrame* aParentFrame = aInsertion.mParentFrame;
>   if (!NeedFrameFor(aState, aParentFrame, aContent)) {
>     return;
>   }
> 
>   // never create frames for comments or PIs
>   if (aContent->IsNodeOfType(nsINode::eCOMMENT) ||
>       aContent->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION))
>     return;
>@@ -6298,36 +6318,35 @@ GetAdjustedParentFrame(nsContainerFrame*
>     if (!aChildContent->IsHTML(nsGkAtoms::legend)) {
>       newParent = GetFieldSetBlockFrame(aParentFrame);
>     }
>   }
>   return newParent ? newParent : aParentFrame;
> }
> 
> nsIFrame*
>-nsCSSFrameConstructor::GetInsertionPrevSibling(nsContainerFrame*& aParentFrame,
>-                                               nsIContent* aContainer,
>+nsCSSFrameConstructor::GetInsertionPrevSibling(InsertionPoint* aInsertion,
>                                                nsIContent* aChild,
>-                                               bool* aIsAppend,
>-                                               bool* aIsRangeInsertSafe,
>+                                               bool*       aIsAppend,
>+                                               bool*       aIsRangeInsertSafe,
>                                                nsIContent* aStartSkipChild,
>                                                nsIContent* aEndSkipChild)
> {
>+  NS_PRECONDITION(aInsertion->mParentFrame, "Must have parent frame to start with");
>+
>   *aIsAppend = false;
> 
>   // Find the frame that precedes the insertion point. Walk backwards
>   // from the parent frame to get the parent content, because if an
>   // XBL insertion point is involved, we'll need to use _that_ to find
>   // the preceding frame.
>-
>-  NS_PRECONDITION(aParentFrame, "Must have parent frame to start with");
>-  nsIContent* container = aParentFrame->GetContent();
>+  nsIContent* container = aInsertion->mParentFrame->GetContent();
> 
>   FlattenedChildIterator iter(container);
>-  bool xblCase = iter.XBLInvolved() || container != aContainer;
>+  bool xblCase = iter.XBLInvolved() || container != aInsertion->mContainer;
>   if (xblCase || !aChild->IsRootOfAnonymousSubtree()) {
>     // The check for IsRootOfAnonymousSubtree() is because editor is
>     // severely broken and calls us directly for native anonymous
>     // nodes that it creates.
>     if (aStartSkipChild) {
>       iter.Seek(aStartSkipChild);
>     } else {
>       iter.Seek(aChild);
>@@ -6343,51 +6362,54 @@ nsCSSFrameConstructor::GetInsertionPrevS
>   // the later usage of the iterator starts from the same place.
>   uint8_t childDisplay = UNSET_DISPLAY;
>   nsIFrame* prevSibling = FindPreviousSibling(iter, childDisplay);
> 
>   // Now, find the geometric parent so that we can handle
>   // continuations properly. Use the prev sibling if we have it;
>   // otherwise use the next sibling.
>   if (prevSibling) {
>-    aParentFrame = prevSibling->GetParent()->GetContentInsertionFrame();
>+    aInsertion->mParentFrame = prevSibling->GetParent()->GetContentInsertionFrame();
>   }
>   else {
>     // If there is no previous sibling, then find the frame that follows
>     if (aEndSkipChild) {
>       iter.Seek(aEndSkipChild);
>       iter.GetPreviousChild();
>     }
>     nsIFrame* nextSibling = FindNextSibling(iter, childDisplay);
> 
>     if (nextSibling) {
>-      aParentFrame = nextSibling->GetParent()->GetContentInsertionFrame();
>+      aInsertion->mParentFrame = nextSibling->GetParent()->GetContentInsertionFrame();
>     }
>     else {
>       // No previous or next sibling, so treat this like an appended frame.
>       *aIsAppend = true;
>-      if (IsFramePartOfIBSplit(aParentFrame)) {
>+      if (IsFramePartOfIBSplit(aInsertion->mParentFrame)) {
>         // Since we're appending, we'll walk to the last anonymous frame
>         // that was created for the broken inline frame.  But don't walk
>         // to the trailing inline if it's empty; stop at the block.
>-        aParentFrame = GetLastIBSplitSibling(aParentFrame, false);
>+        aInsertion->mParentFrame =
>+          GetLastIBSplitSibling(aInsertion->mParentFrame, false);
>       }
>       // Get continuation that parents the last child.  This MUST be done
>       // before the AdjustAppendParentForAfterContent call.
>-      aParentFrame = nsLayoutUtils::LastContinuationWithChild(aParentFrame);
>+      aInsertion->mParentFrame =
>+        nsLayoutUtils::LastContinuationWithChild(aInsertion->mParentFrame);
>       // Deal with fieldsets
>-      aParentFrame = ::GetAdjustedParentFrame(aParentFrame,
>-                                              aParentFrame->GetType(),
>-                                              aChild);
>+      aInsertion->mParentFrame =
>+        ::GetAdjustedParentFrame(aInsertion->mParentFrame,
>+                                 aInsertion->mParentFrame->GetType(),
>+                                 aChild);
>       nsIFrame* appendAfterFrame;
>-      aParentFrame =
>+      aInsertion->mParentFrame =
>         ::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(),
>-                                            container, aParentFrame,
>+                                            container, aInsertion->mParentFrame,
>                                             &appendAfterFrame);
>-      prevSibling = ::FindAppendPrevSibling(aParentFrame, appendAfterFrame);
>+      prevSibling = ::FindAppendPrevSibling(aInsertion->mParentFrame, appendAfterFrame);
>     }
>   }
> 
>   *aIsRangeInsertSafe = (childDisplay == UNSET_DISPLAY);
>   return prevSibling;
> }
> 
> static bool
>@@ -6430,32 +6452,32 @@ MaybeGetListBoxBodyFrame(nsIContent* aCo
>   }
> 
>   return nullptr;
> }
> #endif
> 
> void
> nsCSSFrameConstructor::AddTextItemIfNeeded(nsFrameConstructorState& aState,
>-                                           nsContainerFrame* aParentFrame,
>+                                           const InsertionPoint& aInsertion,
>                                            nsIContent* aPossibleTextContent,
>                                            FrameConstructionItemList& aItems)
> {
>   NS_PRECONDITION(aPossibleTextContent, "Must have node");
>   if (!aPossibleTextContent->IsNodeOfType(nsINode::eTEXT) ||
>       !aPossibleTextContent->HasFlag(NS_CREATE_FRAME_IF_NON_WHITESPACE)) {
>     // Not text, or not suppressed due to being all-whitespace (if it
>     // were being suppressed, it would have the
>     // NS_CREATE_FRAME_IF_NON_WHITESPACE flag)
>     return;
>   }
>   NS_ASSERTION(!aPossibleTextContent->GetPrimaryFrame(),
>                "Text node has a frame and NS_CREATE_FRAME_IF_NON_WHITESPACE");
>   AddFrameConstructionItems(aState, aPossibleTextContent, false,
>-                            aParentFrame, aItems);
>+                            aInsertion, aItems);
> }
> 
> void
> nsCSSFrameConstructor::ReframeTextIfNeeded(nsIContent* aParentContent,
>                                            nsIContent* aContent)
> {
>   if (!aContent->IsNodeOfType(nsINode::eTEXT) ||
>       !aContent->HasFlag(NS_CREATE_FRAME_IF_NON_WHITESPACE)) {
>@@ -6663,71 +6685,71 @@ nsCSSFrameConstructor::IssueSingleInsert
>       continue;
>     }
>     // Call ContentInserted with this node.
>     ContentInserted(aContainer, child, mTempFrameTreeState,
>                     aAllowLazyConstruction);
>   }
> }
> 
>-nsContainerFrame*
>+nsCSSFrameConstructor::InsertionPoint
> nsCSSFrameConstructor::GetRangeInsertionPoint(nsIContent* aContainer,
>                                               nsIContent* aStartChild,
>                                               nsIContent* aEndChild,
>                                               bool aAllowLazyConstruction)
> {
>   // See if we have an XBL insertion point. If so, then that's our
>   // real parent frame; if not, then the frame hasn't been built yet
>   // and we just bail.
>-  bool multiple = false;
>-  nsContainerFrame* insertionPoint = GetInsertionPoint(aContainer, nullptr, &multiple);
>-  if (!insertionPoint && !multiple)
>-    return nullptr; // Don't build the frames.
>+  InsertionPoint insertionPoint = GetInsertionPoint(aContainer, nullptr);
>+  if (!insertionPoint.mParentFrame && !insertionPoint.mMultiple) {
>+    return insertionPoint; // Don't build the frames.
>+  }
> 
>   bool hasInsertion = false;
>-  if (!multiple) {
>+  if (!insertionPoint.mMultiple) {
>     // XXXbz XBL2/sXBL issue
>     nsIDocument* document = aStartChild->GetComposedDoc();
>     // XXXbz how would |document| be null here?
>     if (document && aStartChild->GetXBLInsertionParent()) {
>       hasInsertion = true;
>     }
>   }
> 
>-  if (multiple || hasInsertion) {
>+  if (insertionPoint.mMultiple || hasInsertion) {
>     // We have an insertion point.  There are some additional tests we need to do
>     // in order to ensure that an append is a safe operation.
>     uint32_t childCount = 0;
> 
>-    if (!multiple) {
>+    if (!insertionPoint.mMultiple) {
>       // We may need to make multiple ContentInserted calls instead.  A
>       // reasonable heuristic to employ (in order to maintain good performance)
>       // is to find out if the insertion point's content node contains any
>       // explicit children.  If it does not, then it is highly likely that
>       // an append is occurring.  (Note it is not definite, and there are insane
>       // cases we will not deal with by employing this heuristic, but it beats
>       // always falling back to multiple ContentInserted calls).
>       //
>       // In the multiple insertion point case, we know we're going to need to do
>       // multiple ContentInserted calls anyway.
>       // XXXndeakin This test doesn't work in the new world. Or rather, it works, but
>       // it's slow
>-      childCount = insertionPoint->GetContent()->GetChildCount();
>+      childCount = insertionPoint.mParentFrame->GetContent()->GetChildCount();
>     }
> 
>     // If we have multiple insertion points or if we have an insertion point
>     // and the operation is not a true append or if the insertion point already
>     // has explicit children, then we must fall back.
>-    if (multiple || aEndChild != nullptr || childCount > 0) {
>+    if (insertionPoint.mMultiple || aEndChild != nullptr || childCount > 0) {
>       // Now comes the fun part.  For each inserted child, make a
>       // ContentInserted call as if it had just gotten inserted and
>       // let ContentInserted handle the mess.
>       IssueSingleInsertNofications(aContainer, aStartChild, aEndChild,
>                                    aAllowLazyConstruction);
>-      return nullptr;
>+      insertionPoint.mParentFrame = nullptr;
>     }
>   }
> 
>   return insertionPoint;
> }
> 
> bool
> nsCSSFrameConstructor::MaybeRecreateForFrameset(nsIFrame* aParentFrame,
>@@ -6806,33 +6828,32 @@ nsCSSFrameConstructor::ContentAppended(n
>     //XXXsmaug This is super unefficient!
>     nsIContent* bindingParent = aContainer->GetBindingParent();
>     LAYOUT_PHASE_TEMP_EXIT();
>     nsresult rv = RecreateFramesForContent(bindingParent, false);
>     LAYOUT_PHASE_TEMP_REENTER();
>     return rv;
>   }
> 
>-  // Get the frame associated with the content
>-  nsContainerFrame* parentFrame = ::GetContentInsertionFrameFor(aContainer);
>-
>   // See comment in ContentRangeInserted for why this is necessary.
>-  if (!parentFrame && !aContainer->IsActiveChildrenElement()) {
>+  if (!::GetContentInsertionFrameFor(aContainer) &&
>+      !aContainer->IsActiveChildrenElement()) {
>     return NS_OK;
>   }
> 
>   if (aAllowLazyConstruction &&
>       MaybeConstructLazily(CONTENTAPPEND, aContainer, aFirstNewContent)) {
>     return NS_OK;
>   }
> 
>   LAYOUT_PHASE_TEMP_EXIT();
>-  parentFrame = GetRangeInsertionPoint(aContainer,
>-                                       aFirstNewContent, nullptr,
>-                                       aAllowLazyConstruction);
>+  InsertionPoint insertion =
>+    GetRangeInsertionPoint(aContainer, aFirstNewContent, nullptr,
>+                           aAllowLazyConstruction);
>+  nsContainerFrame*& parentFrame = insertion.mParentFrame;
>   LAYOUT_PHASE_TEMP_REENTER();
>   if (!parentFrame) {
>     return NS_OK;
>   }
> 
>   LAYOUT_PHASE_TEMP_EXIT();
>   if (MaybeRecreateForFrameset(parentFrame, aFirstNewContent, nullptr)) {
>     LAYOUT_PHASE_TEMP_REENTER();
>@@ -6881,17 +6902,17 @@ nsCSSFrameConstructor::ContentAppended(n
>   // insertion points.
>   NS_ASSERTION(parentFrame->GetType() != nsGkAtoms::fieldSetFrame,
>                "Unexpected parent");
> 
>   // Deal with possible :after generated content on the parent
>   nsIFrame* parentAfterFrame;
>   parentFrame =
>     ::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(),
>-                                        aContainer, parentFrame,
>+                                        insertion.mContainer, parentFrame,
>                                         &parentAfterFrame);
> 
>   // Create some new frames
>   nsFrameConstructorState state(mPresShell,
>                                 GetAbsoluteContainingBlock(parentFrame, FIXED_POS),
>                                 GetAbsoluteContainingBlock(parentFrame, ABS_POS),
>                                 GetFloatContainingBlock(parentFrame));
>   state.mTreeMatchContext.InitAncestors(aContainer->AsElement());
>@@ -6926,23 +6947,23 @@ nsCSSFrameConstructor::ContentAppended(n
>     // one.  No need to do all this if our parent type is not block, though,
>     // since WipeContainingBlock already handles that situation.
>     //
>     // Because we're appending, we don't need to worry about any text
>     // after the appended content; there can only be XBL anonymous content
>     // (text in an XBL binding is not suppressed) or generated content
>     // (and bare text nodes are not generated). Native anonymous content
>     // generated by frames never participates in inline layout.
>-    AddTextItemIfNeeded(state, parentFrame,
>+    AddTextItemIfNeeded(state, insertion,
>                         aFirstNewContent->GetPreviousSibling(), items);
>   }
>   for (nsIContent* child = aFirstNewContent;
>        child;
>        child = child->GetNextSibling()) {
>-    AddFrameConstructionItems(state, child, false, parentFrame, items);
>+    AddFrameConstructionItems(state, child, false, insertion, items);
>   }
> 
>   nsIFrame* prevSibling = ::FindAppendPrevSibling(parentFrame, parentAfterFrame);
> 
>   // Perform special check for diddling around with the frames in
>   // a ib-split inline frame.
>   // If we're appending before :after content, then we're not really
>   // appending, so let WipeContainingBlock know that.
>@@ -7244,111 +7265,116 @@ nsCSSFrameConstructor::ContentRangeInser
>     //XXXsmaug This is super unefficient!
>     nsIContent* bindingParent = aContainer->GetBindingParent();
>     LAYOUT_PHASE_TEMP_EXIT();
>     nsresult rv = RecreateFramesForContent(bindingParent, false);
>     LAYOUT_PHASE_TEMP_REENTER();
>     return rv;
>   }
> 
>-  nsContainerFrame* parentFrame = ::GetContentInsertionFrameFor(aContainer);
>-  // The xbl:children element won't have a frame, but default content can have the children as
>-  // a parent. While its uncommon to change the structure of the default content itself, a label,
>-  // for example, can be reframed by having its value attribute set or removed.
>-  if (!parentFrame && !aContainer->IsActiveChildrenElement()) {
>-    return NS_OK;
>-  }
>-
>-  // Otherwise, we've got parent content. Find its frame.
>-  NS_ASSERTION(!parentFrame || parentFrame->GetContent() == aContainer, "New XBL code is possibly wrong!");
>-
>-  if (aAllowLazyConstruction &&
>-      MaybeConstructLazily(CONTENTINSERT, aContainer, aStartChild)) {
>-    return NS_OK;
>-  }
>-
>+  // Put 'parentFrame' inside a scope so we don't confuse it with
>+  // 'insertion.mParentFrame' later.
>+  {
>+    nsContainerFrame* parentFrame = ::GetContentInsertionFrameFor(aContainer);
>+    // The xbl:children element won't have a frame, but default content can have the children as
>+    // a parent. While its uncommon to change the structure of the default content itself, a label,
>+    // for example, can be reframed by having its value attribute set or removed.
>+    if (!parentFrame && !aContainer->IsActiveChildrenElement()) {
>+      return NS_OK;
>+    }
>+
>+    // Otherwise, we've got parent content. Find its frame.
>+    NS_ASSERTION(!parentFrame || parentFrame->GetContent() == aContainer,
>+                 "New XBL code is possibly wrong!");
>+
>+    if (aAllowLazyConstruction &&
>+        MaybeConstructLazily(CONTENTINSERT, aContainer, aStartChild)) {
>+      return NS_OK;
>+    }
>+  }
>+
>+  InsertionPoint insertion;
>   if (isSingleInsert) {
>     // See if we have an XBL insertion point. If so, then that's our
>     // real parent frame; if not, then the frame hasn't been built yet
>     // and we just bail.
>-    parentFrame = GetInsertionPoint(aContainer, aStartChild);
>+    insertion = GetInsertionPoint(aContainer, aStartChild);
>   } else {
>     // Get our insertion point. If we need to issue single ContentInserted's
>     // GetRangeInsertionPoint will take care of that for us.
>     LAYOUT_PHASE_TEMP_EXIT();
>-    parentFrame = GetRangeInsertionPoint(aContainer, aStartChild, aEndChild,
>-                                         aAllowLazyConstruction);
>+    insertion = GetRangeInsertionPoint(aContainer, aStartChild, aEndChild,
>+                                       aAllowLazyConstruction);
>     LAYOUT_PHASE_TEMP_REENTER();
>   }
> 
>-  if (!parentFrame) {
>+  if (!insertion.mParentFrame) {
>     return NS_OK;
>   }
> 
>   bool isAppend, isRangeInsertSafe;
>-  nsIFrame* prevSibling =
>-    GetInsertionPrevSibling(parentFrame, aContainer, aStartChild,
>-                            &isAppend, &isRangeInsertSafe);
>+  nsIFrame* prevSibling = GetInsertionPrevSibling(&insertion, aStartChild,
>+                                                  &isAppend, &isRangeInsertSafe);
> 
>   // check if range insert is safe
>   if (!isSingleInsert && !isRangeInsertSafe) {
>     // must fall back to a single ContertInserted for each child in the range
>     LAYOUT_PHASE_TEMP_EXIT();
>     IssueSingleInsertNofications(aContainer, aStartChild, aEndChild,
>                                  aAllowLazyConstruction);
>     LAYOUT_PHASE_TEMP_REENTER();
>     return NS_OK;
>   }
> 
>-  nsIContent* container = parentFrame->GetContent();
>-
>-  nsIAtom* frameType = parentFrame->GetType();
>+  nsIContent* container = insertion.mParentFrame->GetContent();
>+
>+  nsIAtom* frameType = insertion.mParentFrame->GetType();
>   LAYOUT_PHASE_TEMP_EXIT();
>-  if (MaybeRecreateForFrameset(parentFrame, aStartChild, aEndChild)) {
>+  if (MaybeRecreateForFrameset(insertion.mParentFrame, aStartChild, aEndChild)) {
>     LAYOUT_PHASE_TEMP_REENTER();
>     return NS_OK;
>   }
>   LAYOUT_PHASE_TEMP_REENTER();
> 
>   // We should only get here with fieldsets when doing a single insert, because
>   // fieldsets have multiple insertion points.
>   NS_ASSERTION(isSingleInsert || frameType != nsGkAtoms::fieldSetFrame,
>                "Unexpected parent");
>-  if (IsFrameForFieldSet(parentFrame, frameType) &&
>+  if (IsFrameForFieldSet(insertion.mParentFrame, frameType) &&
>       aStartChild->Tag() == nsGkAtoms::legend) {
>     // Just reframe the parent, since figuring out whether this
>     // should be the new legend and then handling it is too complex.
>     // We could do a little better here --- check if the fieldset already
>     // has a legend which occurs earlier in its child list than this node,
>     // and if so, proceed. But we'd have to extend nsFieldSetFrame
>     // to locate this legend in the inserted frames and extract it.
>     LAYOUT_PHASE_TEMP_EXIT();
>-    nsresult rv = RecreateFramesForContent(parentFrame->GetContent(), false);
>+    nsresult rv = RecreateFramesForContent(insertion.mParentFrame->GetContent(), false);
>     LAYOUT_PHASE_TEMP_REENTER();
>     return rv;
>   }
> 
>   // Don't construct kids of leaves
>-  if (parentFrame->IsLeaf()) {
>+  if (insertion.mParentFrame->IsLeaf()) {
>     // Clear lazy bits so we don't try to construct again.
>     ClearLazyBits(aStartChild, aEndChild);
>     return NS_OK;
>   }
> 
>-  if (parentFrame->IsFrameOfType(nsIFrame::eMathML)) {
>+  if (insertion.mParentFrame->IsFrameOfType(nsIFrame::eMathML)) {
>     LAYOUT_PHASE_TEMP_EXIT();
>-    nsresult rv = RecreateFramesForContent(parentFrame->GetContent(), false);
>+    nsresult rv = RecreateFramesForContent(insertion.mParentFrame->GetContent(), false);
>     LAYOUT_PHASE_TEMP_REENTER();
>     return rv;
>   }
> 
>   nsFrameConstructorState state(mPresShell,
>-                                GetAbsoluteContainingBlock(parentFrame, FIXED_POS),
>-                                GetAbsoluteContainingBlock(parentFrame, ABS_POS),
>-                                GetFloatContainingBlock(parentFrame),
>+                                GetAbsoluteContainingBlock(insertion.mParentFrame, FIXED_POS),
>+                                GetAbsoluteContainingBlock(insertion.mParentFrame, ABS_POS),
>+                                GetFloatContainingBlock(insertion.mParentFrame),
>                                 aFrameState);
>   state.mTreeMatchContext.InitAncestors(aContainer ?
>                                           aContainer->AsElement() :
>                                           nullptr);
> 
>   // Recover state for the containing block - we need to know if
>   // it has :first-letter or :first-line style applied to it. The
>   // reason we care is that the internal structure in these cases
>@@ -7357,148 +7383,147 @@ nsCSSFrameConstructor::ContentRangeInser
>   nsContainerFrame* containingBlock = state.mFloatedItems.containingBlock;
>   bool haveFirstLetterStyle = false;
>   bool haveFirstLineStyle = false;
> 
>   // In order to shave off some cycles, we only dig up the
>   // containing block haveFirst* flags if the parent frame where
>   // the insertion/append is occurring is an inline or block
>   // container. For other types of containers this isn't relevant.
>-  uint8_t parentDisplay = parentFrame->GetDisplay();
>-
>-  // Examine the parentFrame where the insertion is taking
>+  uint8_t parentDisplay = insertion.mParentFrame->GetDisplay();
>+
>+  // Examine the insertion.mParentFrame where the insertion is taking
>   // place. If it's a certain kind of container then some special
>   // processing is done.
>   if ((NS_STYLE_DISPLAY_BLOCK == parentDisplay) ||
>       (NS_STYLE_DISPLAY_LIST_ITEM == parentDisplay) ||
>       (NS_STYLE_DISPLAY_INLINE == parentDisplay) ||
>       (NS_STYLE_DISPLAY_INLINE_BLOCK == parentDisplay)) {
>     // Recover the special style flags for the containing block
>     if (containingBlock) {
>       haveFirstLetterStyle = HasFirstLetterStyle(containingBlock);
>       haveFirstLineStyle =
>         ShouldHaveFirstLineStyle(containingBlock->GetContent(),
>                                  containingBlock->StyleContext());
>     }
> 
>     if (haveFirstLetterStyle) {
>-      // If our current parentFrame is a Letter frame, use its parent as our
>+      // If our current insertion.mParentFrame is a Letter frame, use its parent as our
>       // new parent hint
>-      if (parentFrame->GetType() == nsGkAtoms::letterFrame) {
>-        // If parentFrame is out of flow, then we actually want the parent of
>+      if (insertion.mParentFrame->GetType() == nsGkAtoms::letterFrame) {
>+        // If insertion.mParentFrame is out of flow, then we actually want the parent of
>         // the placeholder frame.
>-        if (parentFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
>+        if (insertion.mParentFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
>           nsPlaceholderFrame* placeholderFrame =
>-            GetPlaceholderFrameFor(parentFrame);
>+            GetPlaceholderFrameFor(insertion.mParentFrame);
>           NS_ASSERTION(placeholderFrame, "No placeholder for out-of-flow?");
>-          parentFrame = placeholderFrame->GetParent();
>+          insertion.mParentFrame = placeholderFrame->GetParent();
>         } else {
>-          parentFrame = parentFrame->GetParent();
>+          insertion.mParentFrame = insertion.mParentFrame->GetParent();
>         }
>       }
> 
>       // Remove the old letter frames before doing the insertion
>       RemoveLetterFrames(state.mPresContext, mPresShell,
>                          state.mFloatedItems.containingBlock);
> 
>       // Removing the letterframes messes around with the frame tree, removing
>       // and creating frames.  We need to reget our prevsibling, parent frame,
>       // etc.
>-      prevSibling = GetInsertionPrevSibling(parentFrame, aContainer,
>-                                            aStartChild, &isAppend,
>+      prevSibling = GetInsertionPrevSibling(&insertion, aStartChild, &isAppend,
>                                             &isRangeInsertSafe);
> 
>       // Need check whether a range insert is still safe.
>       if (!isSingleInsert && !isRangeInsertSafe) {
>         // Need to recover the letter frames first.
>         RecoverLetterFrames(state.mFloatedItems.containingBlock);
> 
>         // must fall back to a single ContertInserted for each child in the range
>         LAYOUT_PHASE_TEMP_EXIT();
>         IssueSingleInsertNofications(aContainer, aStartChild, aEndChild,
>                                      aAllowLazyConstruction);
>         LAYOUT_PHASE_TEMP_REENTER();
>         return NS_OK;
>       }
> 
>-      container = parentFrame->GetContent();
>-      frameType = parentFrame->GetType();
>+      container = insertion.mParentFrame->GetContent();
>+      frameType = insertion.mParentFrame->GetType();
>     }
>   }
> 
>   if (!prevSibling) {
>     // We're inserting the new frames as the first child. See if the
>     // parent has a :before pseudo-element
>-    nsIFrame* firstChild = parentFrame->GetFirstPrincipalChild();
>+    nsIFrame* firstChild = insertion.mParentFrame->GetFirstPrincipalChild();
> 
>     if (firstChild &&
>         nsLayoutUtils::IsGeneratedContentFor(container, firstChild,
>                                              nsCSSPseudoElements::before)) {
>       // Insert the new frames after the last continuation of the :before
>       prevSibling = firstChild->GetTailContinuation();
>-      parentFrame = prevSibling->GetParent()->GetContentInsertionFrame();
>+      insertion.mParentFrame = prevSibling->GetParent()->GetContentInsertionFrame();
>       // Don't change isAppend here; we'll can call AppendFrames as needed, and
>       // the change to our prevSibling doesn't affect that.
>     }
>   }
> 
>   FrameConstructionItemList items;
>   ParentType parentType = GetParentType(frameType);
>   FlattenedChildIterator iter(aContainer);
>   bool haveNoXBLChildren = (!iter.XBLInvolved() || !iter.GetNextChild());
>   if (aStartChild->GetPreviousSibling() &&
>       parentType == eTypeBlock && haveNoXBLChildren) {
>     // If there's a text node in the normal content list just before the
>     // new nodes, and it has no frame, make a frame construction item for
>     // it, because it might need a frame now.  No need to do this if our
>     // parent type is not block, though, since WipeContainingBlock
>     // already handles that sitation.
>-    AddTextItemIfNeeded(state, parentFrame, aStartChild->GetPreviousSibling(),
>+    AddTextItemIfNeeded(state, insertion, aStartChild->GetPreviousSibling(),
>                         items);
>   }
> 
>   if (isSingleInsert) {
>     AddFrameConstructionItems(state, aStartChild,
>                               aStartChild->IsRootOfAnonymousSubtree(),
>-                              parentFrame, items);
>+                              insertion, items);
>   } else {
>     for (nsIContent* child = aStartChild;
>          child != aEndChild;
>          child = child->GetNextSibling()){
>-      AddFrameConstructionItems(state, child, false, parentFrame, items);
>+      AddFrameConstructionItems(state, child, false, insertion, items);
>     }
>   }
> 
>   if (aEndChild && parentType == eTypeBlock && haveNoXBLChildren) {
>     // If there's a text node in the normal content list just after the
>     // new nodes, and it has no frame, make a frame construction item for
>     // it, because it might need a frame now.  No need to do this if our
>     // parent type is not block, though, since WipeContainingBlock
>     // already handles that sitation.
>-    AddTextItemIfNeeded(state, parentFrame, aEndChild, items);
>+    AddTextItemIfNeeded(state, insertion, aEndChild, items);
>   }
> 
>   // Perform special check for diddling around with the frames in
>   // a special inline frame.
>   // If we're appending before :after content, then we're not really
>   // appending, so let WipeContainingBlock know that.
>   LAYOUT_PHASE_TEMP_EXIT();
>-  if (WipeContainingBlock(state, containingBlock, parentFrame, items,
>+  if (WipeContainingBlock(state, containingBlock, insertion.mParentFrame, items,
>                           isAppend, prevSibling)) {
>     LAYOUT_PHASE_TEMP_REENTER();
>     return NS_OK;
>   }
>   LAYOUT_PHASE_TEMP_REENTER();
> 
>   // If the container is a table and a caption will be appended, it needs to be
>   // put in the outer table frame's additional child list.
>   // We make no attempt here to set flags to indicate whether the list
>   // will be at the start or end of a block. It doesn't seem worthwhile.
>   nsFrameItems frameItems, captionItems;
>-  ConstructFramesFromItemList(state, items, parentFrame, frameItems);
>+  ConstructFramesFromItemList(state, items, insertion.mParentFrame, frameItems);
> 
>   if (frameItems.NotEmpty()) {
>     for (nsIContent* child = aStartChild;
>          child != aEndChild;
>          child = child->GetNextSibling()){
>       InvalidateCanvasIfNeeded(mPresShell, child);
>     }
> 
>@@ -7539,74 +7564,75 @@ nsCSSFrameConstructor::ContentRangeInser
>                   frame2->GetType() == nsGkAtoms::tableFrame) ||
>                  frame1->GetType() == nsGkAtoms::fieldSetFrame ||
>                  (frame1->GetParent() &&
>                   frame1->GetParent()->GetType() == nsGkAtoms::fieldSetFrame),
>                  "Unexpected frame types");
> #endif
>     isAppend = true;
>     nsIFrame* appendAfterFrame;
>-    parentFrame =
>+    insertion.mParentFrame =
>       ::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(),
>                                           container,
>                                           frameItems.FirstChild()->GetParent(),
>                                           &appendAfterFrame);
>-    prevSibling = ::FindAppendPrevSibling(parentFrame, appendAfterFrame);
>-  }
>-
>-  if (haveFirstLineStyle && parentFrame == containingBlock) {
>+    prevSibling = ::FindAppendPrevSibling(insertion.mParentFrame, appendAfterFrame);
>+  }
>+
>+  if (haveFirstLineStyle && insertion.mParentFrame == containingBlock) {
>     // It's possible that the new frame goes into a first-line
>     // frame. Look at it and see...
>     if (isAppend) {
>       // Use append logic when appending
>       AppendFirstLineFrames(state, containingBlock->GetContent(),
>                             containingBlock, frameItems);
>     }
>     else {
>       // Use more complicated insert logic when inserting
>       // XXXbz this method is a no-op, so it's easy for the args being passed
>       // here to make no sense without anyone noticing...  If it ever stops
>       // being a no-op, vet them carefully!
>-      InsertFirstLineFrames(state, container, containingBlock, &parentFrame,
>+      InsertFirstLineFrames(state, container, containingBlock, &insertion.mParentFrame,
>                             prevSibling, frameItems);
>     }
>   }
> 
>   // We might have captions; put them into the caption list of the
>   // outer table frame.
>   if (captionItems.NotEmpty()) {
>     NS_ASSERTION(nsGkAtoms::tableFrame == frameType ||
>                  nsGkAtoms::tableOuterFrame == frameType,
>                  "parent for caption is not table?");
>     // We need to determine where to put the caption items; start with the
>     // the parent frame that has already been determined and get the insertion
>     // prevsibling of the first caption item.
>-    nsContainerFrame* captionParent = parentFrame;
>     bool captionIsAppend;
>     nsIFrame* captionPrevSibling = nullptr;
> 
>     // aIsRangeInsertSafe is ignored on purpose because it is irrelevant here.
>     bool ignored;
>+    InsertionPoint captionInsertion(insertion.mParentFrame, insertion.mContainer);
>     if (isSingleInsert) {
>       captionPrevSibling =
>-        GetInsertionPrevSibling(captionParent, aContainer, aStartChild,
>+        GetInsertionPrevSibling(&captionInsertion, aStartChild,
>                                 &captionIsAppend, &ignored);
>     } else {
>       nsIContent* firstCaption = captionItems.FirstChild()->GetContent();
>       // It is very important here that we skip the children in
>       // [aStartChild,aEndChild) when looking for a
>       // prevsibling.
>       captionPrevSibling =
>-        GetInsertionPrevSibling(captionParent, aContainer, firstCaption,
>+        GetInsertionPrevSibling(&captionInsertion, firstCaption,
>                                 &captionIsAppend, &ignored,
>                                 aStartChild, aEndChild);
>     }
> 
>     nsContainerFrame* outerTable = nullptr;
>-    if (GetCaptionAdjustedParent(captionParent, captionItems.FirstChild(),
>+    if (GetCaptionAdjustedParent(captionInsertion.mParentFrame,
>+                                 captionItems.FirstChild(),
>                                  &outerTable)) {
>       // If the parent is not an outer table frame we will try to add frames
>       // to a named child list that the parent does not honour and the frames
>       // will get lost
>       NS_ASSERTION(nsGkAtoms::tableOuterFrame == outerTable->GetType(),
>                    "Pseudo frame construction failure; "
>                    "a caption can be only a child of an outer table frame");
> 
>@@ -7624,32 +7650,32 @@ nsCSSFrameConstructor::ContentRangeInser
>                      captionPrevSibling, captionItems);
>       }
>     }
>   }
> 
>   if (frameItems.NotEmpty()) {
>     // Notify the parent frame
>     if (isAppend) {
>-      AppendFramesToParent(state, parentFrame, frameItems, prevSibling);
>+      AppendFramesToParent(state, insertion.mParentFrame, frameItems, prevSibling);
>     } else {
>-      InsertFrames(parentFrame, kPrincipalList, prevSibling, frameItems);
>+      InsertFrames(insertion.mParentFrame, kPrincipalList, prevSibling, frameItems);
>     }
>   }
> 
>   if (haveFirstLetterStyle) {
>     // Recover the letter frames for the containing block when
>     // it has first-letter style.
>     RecoverLetterFrames(state.mFloatedItems.containingBlock);
>   }
> 
> #ifdef DEBUG
>-  if (gReallyNoisyContentUpdates && parentFrame) {
>+  if (gReallyNoisyContentUpdates && insertion.mParentFrame) {
>     printf("nsCSSFrameConstructor::ContentRangeInserted: resulting frame model:\n");
>-    parentFrame->List(stdout, 0);
>+    insertion.mParentFrame->List(stdout, 0);
>   }
> #endif
> 
> #ifdef ACCESSIBILITY
>   nsAccessibilityService* accService = nsIPresShell::AccService();
>   if (accService) {
>     accService->ContentRangeInserted(mPresShell, aContainer,
>                                      aStartChild, aEndChild);
>@@ -8526,77 +8552,72 @@ nsCSSFrameConstructor::ReplicateFixedFra
>   // XXXbz this is a little screwed up, since the fixed frames will have
>   // broken auto-positioning. Oh, well.
>   NS_ASSERTION(!canvasFrame->GetFirstPrincipalChild(),
>                "leaking frames; doc root continuation must be empty");
>   canvasFrame->SetInitialChildList(kPrincipalList, fixedPlaceholders);
>   return NS_OK;
> }
> 
>-nsContainerFrame*
>-nsCSSFrameConstructor::GetInsertionPoint(nsIContent*   aContainer,
>-                                         nsIContent*   aChildContent,
>-                                         bool*         aMultiple)
>-{
>-  nsBindingManager *bindingManager = mDocument->BindingManager();
>+nsCSSFrameConstructor::InsertionPoint
>+nsCSSFrameConstructor::GetInsertionPoint(nsIContent* aContainer,
>+                                         nsIContent* aChild)
>+{
>+  nsBindingManager* bindingManager = mDocument->BindingManager();
> 
>   nsIContent* insertionElement;
>-  if (aChildContent) {
>+  if (aChild) {
>     // We've got an explicit insertion child. Check to see if it's
>     // anonymous.
>-    if (aChildContent->GetBindingParent() == aContainer) {
>+    if (aChild->GetBindingParent() == aContainer) {
>       // This child content is anonymous. Don't use the insertion
>       // point, since that's only for the explicit kids.
>-      return ::GetContentInsertionFrameFor(aContainer);
>+      return InsertionPoint(GetContentInsertionFrameFor(aContainer), aContainer);
>     }
> 
>     if (nsContentUtils::HasDistributedChildren(aContainer)) {
>       // The container distributes nodes, use the frame of the flattened tree parent.
>       // It may be the case that the node is distributed but not matched to any
>       // insertion points, so there is no flattened parent.
>-      nsIContent* flattenedParent = aChildContent->GetFlattenedTreeParent();
>-      return flattenedParent ? ::GetContentInsertionFrameFor(flattenedParent) : nullptr;
>-    }
>-
>-    insertionElement = bindingManager->FindNestedInsertionPoint(aContainer, aChildContent);
>-  }
>-  else {
>+      nsIContent* flattenedParent = aChild->GetFlattenedTreeParent();
>+      if (flattenedParent) {
>+        return InsertionPoint(GetContentInsertionFrameFor(flattenedParent),
>+                              aContainer);
>+      }
>+      return InsertionPoint();
>+    }
>+
>+    insertionElement = bindingManager->FindNestedInsertionPoint(aContainer, aChild);
>+  } else {
>     if (nsContentUtils::HasDistributedChildren(aContainer)) {
>       // The container distributes nodes to shadow DOM insertion points.
>       // Return with aMultiple set to true to induce callers to insert children
>       // individually into the node's flattened tree parent.
>-      *aMultiple = true;
>-      return nullptr;
>+      return InsertionPoint(nullptr, nullptr, true);
>     }
> 
>     bool multiple;
>     insertionElement = bindingManager->FindNestedSingleInsertionPoint(aContainer, &multiple);
>-
>     if (multiple) {
>-      if (aMultiple) {
>-        *aMultiple = true;
>-      }
>-      return nullptr;
>+      return InsertionPoint(nullptr, nullptr, true);
>     }
>   }
> 
>   if (!insertionElement) {
>     insertionElement = aContainer;
>   }
>-
>-  nsContainerFrame* insertionPoint =
>-    ::GetContentInsertionFrameFor(insertionElement);
>-
>-  // fieldsets have multiple insertion points.  Note that we might
>-  // have to look at insertionElement here...
>-  if (aMultiple && insertionElement->IsHTML(nsGkAtoms::fieldset)) {
>-    *aMultiple = true;
>-  }
>-
>-  return insertionPoint;
>+  InsertionPoint insertion(GetContentInsertionFrameFor(insertionElement),
>+                           aContainer);
>+
>+  // Fieldsets have multiple insertion points.
>+  if (insertionElement->IsHTML(nsGkAtoms::fieldset)) {
>+    insertion.mMultiple = true;
>+  }
>+
>+  return insertion;
> }
> 
> // Capture state for the frame tree rooted at the frame associated with the
> // content object, aContent
> void
> nsCSSFrameConstructor::CaptureStateForFramesOf(nsIContent* aContent,
>                                                nsILayoutHistoryState* aHistoryState)
> {
>@@ -9708,16 +9729,17 @@ nsCSSFrameConstructor::ProcessChildren(n
>                                  itemsToConstruct);
>     }
> 
>     const bool addChildItems = MOZ_LIKELY(mCurrentDepth < kMaxDepth);
>     if (!addChildItems) {
>       NS_WARNING("ProcessChildren max depth exceeded");
>     }
> 
>+    InsertionPoint insertion(aFrame, aFrame->GetContent());
>     FlattenedChildIterator iter(aContent);
>     for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
>       // Get the parent of the content and check if it is a XBL children element
>       // (if the content is a children element then parent != aContent because the
>       // FlattenedChildIterator will transitively iterate through <xbl:children>
>       // for default content). Push the children element as an ancestor here because
>       // it does not have a frame and would not otherwise be pushed as an ancestor.
>       nsIContent* parent = child->GetParent();
>@@ -9732,17 +9754,17 @@ nsCSSFrameConstructor::ProcessChildren(n
>       }
> 
>       // Frame construction item construction should not post
>       // restyles, so removing restyle flags here is safe.
>       if (child->IsElement()) {
>         child->UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS);
>       }
>       if (addChildItems) {
>-        AddFrameConstructionItems(aState, child, iter.XBLInvolved(), aFrame,
>+        AddFrameConstructionItems(aState, child, iter.XBLInvolved(), insertion,
>                                   itemsToConstruct);
>       } else {
>         ClearLazyBits(child, child->GetNextSibling());
>       }
>     }
>     itemsToConstruct.SetParentHasNoXBLChildren(!iter.XBLInvolved());
> 
>     if (aCanHaveGeneratedContent) {
>diff --git a/layout/base/nsCSSFrameConstructor.h b/layout/base/nsCSSFrameConstructor.h
>--- a/layout/base/nsCSSFrameConstructor.h
>+++ b/layout/base/nsCSSFrameConstructor.h
>@@ -102,25 +102,58 @@ private:
> 
>   // Issues a single ContentInserted for each child of aContainer in the range
>   // [aStartChild, aEndChild).
>   void IssueSingleInsertNofications(nsIContent* aContainer,
>                                     nsIContent* aStartChild,
>                                     nsIContent* aEndChild,
>                                     bool aAllowLazyConstruction);
> 
>-  // Checks if the children of aContainer in the range [aStartChild, aEndChild)
>-  // can be inserted/appended to one insertion point together. If so, returns
>-  // that insertion point. If not, returns null and issues single
>-  // ContentInserted calls for each child.  aEndChild = nullptr indicates that we
>-  // are dealing with an append.
>-  nsContainerFrame* GetRangeInsertionPoint(nsIContent* aContainer,
>-                                           nsIContent* aStartChild,
>-                                           nsIContent* aEndChild,
>-                                           bool aAllowLazyConstruction);
>+  /**
>+   * Data that represents an insertion point for some child content.
>+   */
>+  struct InsertionPoint
>+  {
>+    InsertionPoint()
>+      : mParentFrame(nullptr), mContainer(nullptr), mMultiple(false) {}
>+    InsertionPoint(nsContainerFrame* aParentFrame, nsIContent* aContainer,
>+                   bool aMultiple = false)
>+      : mParentFrame(aParentFrame), mContainer(aContainer),
>+        mMultiple(aMultiple) {}
>+    /**
>+     * The parent frame to use if the inserted children needs to create
>+     * frame(s).  May be null, which signals that  we shouldn't try to
>+     * create frames for the inserted children; either because there are
>+     * no parent frame or because there are multiple insertion points and
>+     * we will call IssueSingleInsertNofications for each child instead.
>+     * mContainer should not be used when mParentFrame is null.
>+     */
>+    nsContainerFrame* mParentFrame;
>+    /**
>+     * The container for the inserted children.
>+     * It's undefined if mParentFrame is null.
>+     */
>+    nsIContent* mContainer;
>+    /**
>+     * If true then there are multiple insertion points, which means consumers
>+     * should insert children individually into the node's flattened tree parent.
>+     */
>+    bool mMultiple;
>+  };
>+  /**
>+   * Checks if the children of aContainer in the range [aStartChild, aEndChild)
>+   * can be inserted/appended to one insertion point together. If so, returns
>+   * that insertion point. If not, returns with InsertionPoint.mFrame == nullptr
>+   * and issues single ContentInserted calls for each child.
>+   * aEndChild = nullptr indicates that we are dealing with an append.
>+   */
>+  InsertionPoint GetRangeInsertionPoint(nsIContent* aContainer,
>+                                        nsIContent* aStartChild,
>+                                        nsIContent* aEndChild,
>+                                        bool aAllowLazyConstruction);
> 
>   // Returns true if parent was recreated due to frameset child, false otherwise.
>   bool MaybeRecreateForFrameset(nsIFrame* aParentFrame,
>                                   nsIContent* aStartChild,
>                                   nsIContent* aEndChild);
> 
> public:
>   /**
>@@ -231,20 +264,20 @@ public:
>   nsIFrame* CreateContinuingFrame(nsPresContext*    aPresContext,
>                                   nsIFrame*         aFrame,
>                                   nsContainerFrame* aParentFrame,
>                                   bool              aIsFluid = true);
> 
>   // Copy over fixed frames from aParentFrame's prev-in-flow
>   nsresult ReplicateFixedFrames(nsPageContentFrame* aParentFrame);
> 
>-  // Get the XBL insertion point for a child
>-  nsContainerFrame* GetInsertionPoint(nsIContent* aContainer,
>-                                      nsIContent* aChildContent,
>-                                      bool*       aMultiple = nullptr);
>+  /**
>+   * Get the XBL insertion point for aChild in aContainer.
>+   */
>+  InsertionPoint GetInsertionPoint(nsIContent* aContainer, nsIContent* aChild);
> 
>   nsresult CreateListBoxContent(nsPresContext*    aPresContext,
>                                 nsContainerFrame* aParentFrame,
>                                 nsIFrame*         aPrevFrame,
>                                 nsIContent*       aChild,
>                                 nsIFrame**        aResult,
>                                 bool              aIsAppend,
>                                 bool              aIsScrollbar,
>@@ -277,33 +310,42 @@ private:
>                             nsIContent*                    aContent,
>                             nsContainerFrame*              aParentFrame,
>                             nsIFrame*                      aNewFrame,
>                             bool                           aAllowCounters = true);
> 
>   // aState can be null if not available; it's used as an optimization.
>   // XXXbz IsValidSibling is the only caller that doesn't pass a state here!
>   already_AddRefed<nsStyleContext>
>-  ResolveStyleContext(nsIFrame*         aParentFrame,
>-                      nsIContent*       aContent,
>+  ResolveStyleContext(nsIFrame*                aParentFrame,
>+                      nsIContent*              aContainer,
>+                      nsIContent*              aChild,
>                       nsFrameConstructorState* aState);
>   already_AddRefed<nsStyleContext>
>-  ResolveStyleContext(nsStyleContext* aParentStyleContext,
>-                      nsIContent* aContent,
>+  ResolveStyleContext(nsIFrame*                aParentFrame,
>+                      nsIContent*              aChild,
>+                      nsFrameConstructorState* aState);
>+  already_AddRefed<nsStyleContext>
>+  ResolveStyleContext(const InsertionPoint&    aInsertion,
>+                      nsIContent*              aChild,
>+                      nsFrameConstructorState* aState);
>+  already_AddRefed<nsStyleContext>
>+  ResolveStyleContext(nsStyleContext*          aParentStyleContext,
>+                      nsIContent*              aContent,
>                       nsFrameConstructorState* aState);
> 
>   // Add the frame construction items for the given aContent and aParentFrame
>   // to the list.  This might add more than one item in some rare cases.
>   // If aSuppressWhiteSpaceOptimizations is true, optimizations that
>   // may suppress the construction of white-space-only text frames
>   // must be skipped for these items and items around them.
>   void AddFrameConstructionItems(nsFrameConstructorState& aState,
>                                  nsIContent*              aContent,
>                                  bool                     aSuppressWhiteSpaceOptimizations,
>-                                 nsContainerFrame*        aParentFrame,
>+                                 const InsertionPoint&    aInsertion,
>                                  FrameConstructionItemList& aItems);
> 
>   // Construct the frames for the document element.  This can return null if the
>   // document element is display:none, or if the document element has a
>   // not-yet-loaded XBL binding, or if it's an SVG element that's not <svg>.
>   nsIFrame* ConstructDocElementFrame(Element*                 aDocElement,
>                                      nsILayoutHistoryState*   aFrameState);
> 
>@@ -1119,17 +1161,17 @@ private:
>                           nsIContent*              aContent,
>                           nsContainerFrame*        aParentFrame,
>                           nsStyleContext*          aStyleContext,
>                           nsFrameItems&            aFrameItems);
> 
>   // If aPossibleTextContent is a text node and doesn't have a frame, append a
>   // frame construction item for it to aItems.
>   void AddTextItemIfNeeded(nsFrameConstructorState& aState,
>-                           nsContainerFrame* aParentFrame,
>+                           const InsertionPoint& aInsertion,
>                            nsIContent* aPossibleTextContent,
>                            FrameConstructionItemList& aItems);
> 
>   // If aParentContent's child aContent is a text node and
>   // doesn't have a frame, try to create a frame for it.
>   void ReframeTextIfNeeded(nsIContent* aParentContent,
>                            nsIContent* aContent);
> 
>@@ -1749,18 +1791,17 @@ private:
>   // aChild being the first child in the range. It is the callers'
>   // responsibility to check whether a range insert is safe with regards to
>   // fieldsets.
>   // The skip parameters are used to ignore a range of children when looking
>   // for a sibling. All nodes starting from aStartSkipChild and up to but not
>   // including aEndSkipChild will be skipped over when looking for sibling
>   // frames. Skipping a range can deal with XBL but not when there are multiple
>   // insertion points.
>-  nsIFrame* GetInsertionPrevSibling(nsContainerFrame*& aParentFrame, /* inout */
>-                                    nsIContent* aContainer,
>+  nsIFrame* GetInsertionPrevSibling(InsertionPoint* aInsertion, // inout
>                                     nsIContent* aChild,
>                                     bool* aIsAppend,
>                                     bool* aIsRangeInsertSafe,
>                                     nsIContent* aStartSkipChild = nullptr,
>                                     nsIContent *aEndSkipChild = nullptr);
> 
>   // see if aContent and aSibling are legitimate siblings due to restrictions
>   // imposed by table columns
>diff --git a/layout/xul/nsMenuBarFrame.cpp b/layout/xul/nsMenuBarFrame.cpp
>--- a/layout/xul/nsMenuBarFrame.cpp
>+++ b/layout/xul/nsMenuBarFrame.cpp
>@@ -172,18 +172,19 @@ nsMenuBarFrame::FindMenuWithShortcut(nsI
>     nsContentUtils::GetAccessKeyCandidates(nativeKeyEvent, accessKeys);
>   if (accessKeys.IsEmpty() && charCode)
>     accessKeys.AppendElement(charCode);
> 
>   if (accessKeys.IsEmpty())
>     return nullptr; // no character was pressed so just return
> 
>   // Enumerate over our list of frames.
>-  nsIFrame* immediateParent = PresContext()->PresShell()->FrameConstructor()->
>+  auto insertion = PresContext()->PresShell()->FrameConstructor()->
>     GetInsertionPoint(GetContent(), nullptr);
>+  nsContainerFrame* immediateParent = insertion.mParentFrame;
>   if (!immediateParent)
>     immediateParent = this;
> 
>   // Find a most preferred accesskey which should be returned.
>   nsIFrame* foundMenu = nullptr;
>   size_t foundIndex = accessKeys.NoIndex;
>   nsIFrame* currFrame = immediateParent->GetFirstPrincipalChild();
> 
>diff --git a/layout/xul/nsMenuPopupFrame.cpp b/layout/xul/nsMenuPopupFrame.cpp
>--- a/layout/xul/nsMenuPopupFrame.cpp
>+++ b/layout/xul/nsMenuPopupFrame.cpp
>@@ -1668,18 +1668,19 @@ nsMenuPopupFrame::FindMenuWithShortcut(n
> {
>   uint32_t charCode, keyCode;
>   aKeyEvent->GetCharCode(&charCode);
>   aKeyEvent->GetKeyCode(&keyCode);
> 
>   doAction = false;
> 
>   // Enumerate over our list of frames.
>-  nsContainerFrame* immediateParent = PresContext()->PresShell()->
>+  auto insertion = PresContext()->PresShell()->
>     FrameConstructor()->GetInsertionPoint(GetContent(), nullptr);
>+  nsContainerFrame* immediateParent = insertion.mParentFrame;
>   if (!immediateParent)
>     immediateParent = this;
> 
>   uint32_t matchCount = 0, matchShortcutCount = 0;
>   bool foundActive = false;
>   bool isShortcut;
>   nsMenuFrame* frameBefore = nullptr;
>   nsMenuFrame* frameAfter = nullptr;
>diff --git a/layout/xul/nsXULPopupManager.cpp b/layout/xul/nsXULPopupManager.cpp
>--- a/layout/xul/nsXULPopupManager.cpp
>+++ b/layout/xul/nsXULPopupManager.cpp
>@@ -2186,18 +2186,19 @@ nsXULPopupManager::HandleKeyboardEventWi
> }
> 
> nsMenuFrame*
> nsXULPopupManager::GetNextMenuItem(nsContainerFrame* aParent,
>                                    nsMenuFrame* aStart,
>                                    bool aIsPopup)
> {
>   nsPresContext* presContext = aParent->PresContext();
>-  nsContainerFrame* immediateParent = presContext->PresShell()->
>+  auto insertion = presContext->PresShell()->
>     FrameConstructor()->GetInsertionPoint(aParent->GetContent(), nullptr);
>+  nsContainerFrame* immediateParent = insertion.mParentFrame;
>   if (!immediateParent)
>     immediateParent = aParent;
> 
>   nsIFrame* currFrame = nullptr;
>   if (aStart) {
>     if (aStart->GetNextSibling())
>       currFrame = aStart->GetNextSibling();
>     else if (aStart->GetParent()->GetContent()->IsXUL(nsGkAtoms::menugroup))
>@@ -2246,18 +2247,19 @@ nsXULPopupManager::GetNextMenuItem(nsCon
> }
> 
> nsMenuFrame*
> nsXULPopupManager::GetPreviousMenuItem(nsContainerFrame* aParent,
>                                        nsMenuFrame* aStart,
>                                        bool aIsPopup)
> {
>   nsPresContext* presContext = aParent->PresContext();
>-  nsContainerFrame* immediateParent = presContext->PresShell()->
>+  auto insertion = presContext->PresShell()->
>     FrameConstructor()->GetInsertionPoint(aParent->GetContent(), nullptr);
>+  nsContainerFrame* immediateParent = insertion.mParentFrame;
>   if (!immediateParent)
>     immediateParent = aParent;
> 
>   const nsFrameList& frames(immediateParent->PrincipalChildList());
> 
>   nsIFrame* currFrame = nullptr;
>   if (aStart) {
>     if (aStart->GetPrevSibling())

Flags:

MatsPalmgren_bugz: review+

Actions: View | Diff | Review

Attachments on bug 907396: 802681 | 802684 | 802685 | 802686 | 802687 | 802688 | 802689 | 802691 | 802692 | 802694 | 802695 | 805961 | 805966 | 805978 | 805980 | 805982 | 806000 | 806002 | 806173 | 806174 | 806177 | 8392917 | 8392920 | 8392929 | 8392932 | 8392934 | 8392953 | 8392954 | 8408496 | 8442107 | 8442117 | 8442176 | 8442192 | 8455264 | 8455266 | 8455274 | 8455281 | 8455290 | 8455386 | 8455502 | 8455503 | 8457452 | 8492588 | 8492589 | 8492590 | 8492591 | 8492593 | 8492594 | 8492595 | 8492596 | 8492597 | 8492598 | 8492600 | 8492601 | 8492602 | 8492603 | 8493349 | 8493408 | 8493412 | 8493953 | 8493956 | 8493957 | 8493977 | 8498158 | 8498173 | 8498181 | 8498189 | 8498191 | 8498197 | 8507588 | 8509088 | 8509092 | 8509095 | 8509098 | 8521591 | 8521869 | 8521871 | 8521873