The Tor Browser / file revision

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

 /*

  * construction of a frame tree that is nearly isomorphic to the content

  * tree and updating of that tree in response to dynamic changes

  */

 #include "nsCSSFrameConstructor.h"

 #include "mozilla/AutoRestore.h"

 #include "mozilla/DebugOnly.h"

 #include "mozilla/dom/HTMLSelectElement.h"

 #include "mozilla/EventStates.h"

 #include "mozilla/Likely.h"

 #include "mozilla/LinkedList.h"

 #include "nsAbsoluteContainingBlock.h"

 #include "nsIAtom.h"

 #include "nsIFrameInlines.h"

 #include "nsGkAtoms.h"

 #include "nsPresContext.h"

 #include "nsIDocument.h"

 #include "nsTableFrame.h"

 #include "nsTableColFrame.h"

 #include "nsIDOMHTMLDocument.h"

 #include "nsHTMLParts.h"

 #include "nsIPresShell.h"

 #include "nsUnicharUtils.h"

 #include "nsStyleSet.h"

 #include "nsViewManager.h"

 #include "nsStyleConsts.h"

 #include "nsIDOMXULElement.h"

 #include "nsContainerFrame.h"

 #include "nsNameSpaceManager.h"

 #include "nsIComboboxControlFrame.h"

 #include "nsIListControlFrame.h"

 #include "nsIDOMCharacterData.h"

 #include "nsPlaceholderFrame.h"

 #include "nsTableRowGroupFrame.h"

 #include "nsIFormControl.h"

 #include "nsCSSAnonBoxes.h"

 #include "nsTextFragment.h"

 #include "nsIAnonymousContentCreator.h"

 #include "nsBindingManager.h"

 #include "nsXBLBinding.h"

 #include "nsContentUtils.h"

 #include "nsIScriptError.h"

 #ifdef XP_MACOSX

 #include "nsIDocShell.h"

 #endif

 #include "ChildIterator.h"

 #include "nsError.h"

 #include "nsLayoutUtils.h"

 #include "nsAutoPtr.h"

 #include "nsBoxFrame.h"

 #include "nsBoxLayout.h"

 #include "nsFlexContainerFrame.h"

 #include "nsGridContainerFrame.h"

 #include "nsImageFrame.h"

 #include "nsIObjectLoadingContent.h"

 #include "nsTArray.h"

 #include "nsGenericDOMDataNode.h"

 #include "mozilla/dom/Element.h"

 #include "nsAutoLayoutPhase.h"

 #include "nsStyleStructInlines.h"

 #include "nsPageContentFrame.h"

 #include "RestyleManager.h"

 #include "StickyScrollContainer.h"

 #include "nsFieldSetFrame.h"

 #ifdef MOZ_XUL

 #include "nsIRootBox.h"

 #endif

 #ifdef ACCESSIBILITY

 #include "nsAccessibilityService.h"

 #endif

 #include "nsBlockFrame.h"

 #include "nsIScrollableFrame.h"

 #include "nsXBLService.h"

 #undef NOISY_FIRST_LETTER

 #include "nsMathMLParts.h"

 #include "mozilla/dom/SVGTests.h"

 #include "nsSVGUtils.h"

 #include "nsRefreshDriver.h"

 #include "nsRuleProcessorData.h"

 #include "nsTextNode.h"

 using namespace mozilla;

 using namespace mozilla::dom;

 // An alias for convenience.

 static const nsIFrame::ChildListID kPrincipalList = nsIFrame::kPrincipalList;

 nsIFrame*

 NS_NewHTMLCanvasFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewHTMLVideoFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGOuterSVGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGOuterSVGAnonChildFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGInnerSVGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGPathGeometryFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGGenericContainerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGForeignObjectFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGAFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGTextFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGContainerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGUseFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGViewFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 extern nsIFrame*

 NS_NewSVGLinearGradientFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);

 extern nsIFrame*

 NS_NewSVGRadialGradientFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);

 extern nsIFrame*

 NS_NewSVGStopFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGMarkerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGMarkerAnonChildFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 extern nsIFrame*

 NS_NewSVGImageFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGClipPathFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGFilterFrame(nsIPresShell *aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGPatternFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGMaskFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGFEContainerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGFELeafFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGFEImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSVGFEUnstyledLeafFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 #include "nsINodeInfo.h"

 #include "prenv.h"

 #include "nsNodeInfoManager.h"

 #include "nsContentCreatorFunctions.h"

 #ifdef DEBUG

 // Set the environment variable GECKO_FRAMECTOR_DEBUG_FLAGS to one or

 // more of the following flags (comma separated) for handy debug

 // output.

 static bool gNoisyContentUpdates = false;

 static bool gReallyNoisyContentUpdates = false;

 static bool gNoisyInlineConstruction = false;

 struct FrameCtorDebugFlags {

   const char* name;

   bool* on;

 };

 static FrameCtorDebugFlags gFlags[] = {

   { "content-updates",              &gNoisyContentUpdates },

   { "really-noisy-content-updates", &gReallyNoisyContentUpdates },

   { "noisy-inline",                 &gNoisyInlineConstruction }

 };

 #define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))

 #endif

 #ifdef MOZ_XUL

 #include "nsMenuFrame.h"

 #include "nsPopupSetFrame.h"

 #include "nsTreeColFrame.h"

 #include "nsIBoxObject.h"

 #include "nsPIListBoxObject.h"

 #include "nsListBoxBodyFrame.h"

 #include "nsListItemFrame.h"

 #include "nsXULLabelFrame.h"

 //------------------------------------------------------------------

 nsIFrame*

 NS_NewAutoRepeatBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewRootBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewDocElementBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewThumbFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewDeckFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewLeafBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewStackFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewProgressMeterFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewRangeFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewImageBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewTextBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewGroupBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewButtonBoxFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewSplitterFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewMenuPopupFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewPopupSetFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewMenuFrame (nsIPresShell* aPresShell, nsStyleContext* aContext, uint32_t aFlags);

 nsIFrame*

 NS_NewMenuBarFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewTreeBodyFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 // grid

 nsresult

 NS_NewGridLayout2 ( nsIPresShell* aPresShell, nsBoxLayout** aNewLayout );

 nsIFrame*

 NS_NewGridRowLeafFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewGridRowGroupFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 // end grid

 nsIFrame*

 NS_NewTitleBarFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewResizerFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 #endif

 nsIFrame*

 NS_NewHTMLScrollFrame (nsIPresShell* aPresShell, nsStyleContext* aContext, bool aIsRoot);

 nsIFrame*

 NS_NewXULScrollFrame (nsIPresShell* aPresShell, nsStyleContext* aContext,

                       bool aIsRoot, bool aClipAllDescendants);

 nsIFrame*

 NS_NewSliderFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewScrollbarFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 nsIFrame*

 NS_NewScrollbarButtonFrame (nsIPresShell* aPresShell, nsStyleContext* aContext);

 #ifdef NOISY_FINDFRAME

 static int32_t FFWC_totalCount=0;

 static int32_t FFWC_doLoop=0;

 static int32_t FFWC_doSibling=0;

 static int32_t FFWC_recursions=0;

 static int32_t FFWC_nextInFlows=0;

 #endif

 // Returns true if aFrame is an anonymous flex item

 static inline bool

 IsAnonymousFlexItem(const nsIFrame* aFrame)

 {

   const nsIAtom* pseudoType = aFrame->StyleContext()->GetPseudo();

   return pseudoType == nsCSSAnonBoxes::anonymousFlexItem;

 }

 static inline nsIFrame*

 GetFieldSetBlockFrame(nsIFrame* aFieldsetFrame)

 {

   // Depends on the fieldset child frame order - see ConstructFieldSetFrame() below.

   nsIFrame* firstChild = aFieldsetFrame->GetFirstPrincipalChild();

   nsIFrame* inner = firstChild && firstChild->GetNextSibling() ? firstChild->GetNextSibling() : firstChild;

   return inner ? inner->GetContentInsertionFrame() : nullptr;

 }

 #define FCDATA_DECL(_flags, _func)                          \

   { _flags, { (FrameCreationFunc)_func }, nullptr, nullptr }

 #define FCDATA_WITH_WRAPPING_BLOCK(_flags, _func, _anon_box)  \

   { _flags | FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS,        \

       { (FrameCreationFunc)_func }, nullptr, &_anon_box }

 //----------------------------------------------------------------------

 /**

  * True if aFrame is an actual inline frame in the sense of non-replaced

  * display:inline CSS boxes.  In other words, it can be affected by {ib}

  * splitting and can contain first-letter frames.  Basically, this is either an

  * inline frame (positioned or otherwise) or an line frame (this last because

  * it can contain first-letter and because inserting blocks in the middle of it

  * needs to terminate it).

  */

 static bool

 IsInlineFrame(const nsIFrame* aFrame)

 {

   return aFrame->IsFrameOfType(nsIFrame::eLineParticipant);

 }

 /**

  * True if aFrame is an instance of an SVG frame class or is an inline/block

  * frame being used for SVG text.

  */

 static bool

 IsFrameForSVG(const nsIFrame* aFrame)

 {

   return aFrame->IsFrameOfType(nsIFrame::eSVG) ||

          aFrame->IsSVGText();

 }

 /**

  * Returns true iff aFrame explicitly prevents its descendants from floating

  * (at least, down to the level of descendants which themselves are

  * float-containing blocks -- those will manage the floating status of any

  * lower-level descendents inside them, of course).

  */

 static bool

 ShouldSuppressFloatingOfDescendants(nsIFrame* aFrame)

 {

   return aFrame->IsFrameOfType(nsIFrame::eMathML) ||

     aFrame->IsBoxFrame() ||

     aFrame->GetType() == nsGkAtoms::flexContainerFrame ||

     aFrame->GetType() == nsGkAtoms::gridContainerFrame;

 }

 /**

  * If any children require a block parent, return the first such child.

  * Otherwise return null.

  */

 static nsIContent*

 AnyKidsNeedBlockParent(nsIFrame *aFrameList)

 {

   for (nsIFrame *k = aFrameList; k; k = k->GetNextSibling()) {

     // Line participants, such as text and inline frames, can't be

     // directly inside a XUL box; they must be wrapped in an

     // intermediate block.

     if (k->IsFrameOfType(nsIFrame::eLineParticipant)) {

       return k->GetContent();

     }

   }

   return nullptr;

 }

 // Reparent a frame into a wrapper frame that is a child of its old parent.

 static void

 ReparentFrame(RestyleManager* aRestyleManager,

               nsIFrame* aNewParentFrame,

               nsIFrame* aFrame)

 {

   aFrame->SetParent(aNewParentFrame);

   aRestyleManager->ReparentStyleContext(aFrame);

 }

 static void

 ReparentFrames(nsCSSFrameConstructor* aFrameConstructor,

                nsIFrame* aNewParentFrame,

                const nsFrameList& aFrameList)

 {

   RestyleManager* restyleManager = aFrameConstructor->RestyleManager();

   for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {

     ReparentFrame(restyleManager, aNewParentFrame, e.get());

   }

 }

 //----------------------------------------------------------------------

 //

 // When inline frames get weird and have block frames in them, we

 // annotate them to help us respond to incremental content changes

 // more easily.

 static inline bool

 IsFramePartOfIBSplit(nsIFrame* aFrame)

 {

   return (aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) != 0;

 }

 static nsIFrame* GetIBSplitSibling(nsIFrame* aFrame)

 {

   NS_PRECONDITION(IsFramePartOfIBSplit(aFrame), "Shouldn't call this");

   // We only store the "ib-split sibling" annotation with the first

   // frame in the continuation chain. Walk back to find that frame now.

   return static_cast<nsIFrame*>

     (aFrame->FirstContinuation()->

        Properties().Get(nsIFrame::IBSplitSibling()));

 }

 static nsIFrame* GetIBSplitPrevSibling(nsIFrame* aFrame)

 {

   NS_PRECONDITION(IsFramePartOfIBSplit(aFrame), "Shouldn't call this");

   // We only store the ib-split sibling annotation with the first

   // frame in the continuation chain. Walk back to find that frame now.

   return static_cast<nsIFrame*>

     (aFrame->FirstContinuation()->

        Properties().Get(nsIFrame::IBSplitPrevSibling()));

 }

 static nsIFrame*

 GetLastIBSplitSibling(nsIFrame* aFrame, bool aReturnEmptyTrailingInline)

 {

   for (nsIFrame *frame = aFrame, *next; ; frame = next) {

     next = GetIBSplitSibling(frame);

     if (!next ||

         (!aReturnEmptyTrailingInline && !next->GetFirstPrincipalChild() &&

          !GetIBSplitSibling(next))) {

       NS_ASSERTION(!next || !frame->IsInlineOutside(),

                    "Should have a block here!");

       return frame;

     }

   }

   NS_NOTREACHED("unreachable code");

   return nullptr;

 }

 static void

 SetFrameIsIBSplit(nsIFrame* aFrame, nsIFrame* aIBSplitSibling)

 {

   NS_PRECONDITION(aFrame, "bad args!");

   // We should be the only continuation

   NS_ASSERTION(!aFrame->GetPrevContinuation(),

                "assigning ib-split sibling to other than first continuation!");

   NS_ASSERTION(!aFrame->GetNextContinuation() ||

                IsFramePartOfIBSplit(aFrame->GetNextContinuation()),

                "should have no non-ib-split continuations here");

   // Mark the frame as ib-split.

   aFrame->AddStateBits(NS_FRAME_PART_OF_IBSPLIT);

   if (aIBSplitSibling) {

     NS_ASSERTION(!aIBSplitSibling->GetPrevContinuation(),

                  "assigning something other than the first continuation as the "

                  "ib-split sibling");

     // Store the ib-split sibling (if we were given one) with the

     // first frame in the flow.

     FramePropertyTable* props = aFrame->PresContext()->PropertyTable();

     props->Set(aFrame, nsIFrame::IBSplitSibling(), aIBSplitSibling);

     props->Set(aIBSplitSibling, nsIFrame::IBSplitPrevSibling(), aFrame);

   }

 }

 static nsIFrame*

 GetIBContainingBlockFor(nsIFrame* aFrame)

 {

   NS_PRECONDITION(IsFramePartOfIBSplit(aFrame),

                   "GetIBContainingBlockFor() should only be called on known IB frames");

   // Get the first "normal" ancestor of the target frame.

   nsIFrame* parentFrame;

   do {

     parentFrame = aFrame->GetParent();

     if (! parentFrame) {

       NS_ERROR("no unsplit block frame in IB hierarchy");

       return aFrame;

     }

     // Note that we ignore non-ib-split frames which have a pseudo on their

     // style context -- they're not the frames we're looking for!  In

     // particular, they may be hiding a real parent that _is_ in an ib-split.

     if (!IsFramePartOfIBSplit(parentFrame) &&

         !parentFrame->StyleContext()->GetPseudo())

       break;

     aFrame = parentFrame;

   } while (1);

   // post-conditions

   NS_ASSERTION(parentFrame, "no normal ancestor found for ib-split frame "

                             "in GetIBContainingBlockFor");

   NS_ASSERTION(parentFrame != aFrame, "parentFrame is actually the child frame - bogus reslt");

   return parentFrame;

 }

 //----------------------------------------------------------------------

 // Block/inline frame construction logic. We maintain a few invariants here:

 //

 // 1. Block frames contain block and inline frames.

 //

 // 2. Inline frames only contain inline frames. If an inline parent has a block

 // child then the block child is migrated upward until it lands in a block

 // parent (the inline frames containing block is where it will end up).

 // After this function returns, aLink is pointing to the first link at or

 // after its starting position for which the next frame is a block.  If there

 // is no such link, it points to the end of the list.

 static void

 FindFirstBlock(nsFrameList::FrameLinkEnumerator& aLink)

 {

   for ( ; !aLink.AtEnd(); aLink.Next()) {

     if (!aLink.NextFrame()->IsInlineOutside()) {

       return;

     }

   }

 }

 // This function returns a frame link enumerator pointing to the first link in

 // the list for which the next frame is not block.  If there is no such link,

 // it points to the end of the list.

 static nsFrameList::FrameLinkEnumerator

 FindFirstNonBlock(const nsFrameList& aList)

 {

   nsFrameList::FrameLinkEnumerator link(aList);

   for (; !link.AtEnd(); link.Next()) {

     if (link.NextFrame()->IsInlineOutside()) {

       break;

     }

   }

   return link;

 }

 inline void

 SetInitialSingleChild(nsIFrame* aParent, nsIFrame* aFrame)

 {

   NS_PRECONDITION(!aFrame->GetNextSibling(), "Should be using a frame list");

   nsFrameList temp(aFrame, aFrame);

   aParent->SetInitialChildList(kPrincipalList, temp);

 }

 // -----------------------------------------------------------

 // Structure used when constructing formatting object trees.

 struct nsFrameItems : public nsFrameList

 {

   // Appends the frame to the end of the list

   void AddChild(nsIFrame* aChild);

 };

 void

 nsFrameItems::AddChild(nsIFrame* aChild)

 {

   NS_PRECONDITION(aChild, "nsFrameItems::AddChild");

   // It'd be really nice if we could just AppendFrames(kPrincipalList, aChild) here,

   // but some of our callers put frames that have different

   // parents (caption, I'm looking at you) on the same framelist, and

   // nsFrameList asserts if you try to do that.

   if (IsEmpty()) {

     SetFrames(aChild);

   }

   else {

     NS_ASSERTION(aChild != mLastChild,

                  "Same frame being added to frame list twice?");

     mLastChild->SetNextSibling(aChild);

     mLastChild = nsLayoutUtils::GetLastSibling(aChild);

   }

 }

 // -----------------------------------------------------------

 // Structure used when constructing formatting object trees. Contains

 // state information needed for absolutely positioned elements

 struct nsAbsoluteItems : nsFrameItems {

   // containing block for absolutely positioned elements

   nsIFrame* containingBlock;

   nsAbsoluteItems(nsIFrame* aContainingBlock);

 #ifdef DEBUG

   // XXXbz Does this need a debug-only assignment operator that nulls out the

   // childList in the nsAbsoluteItems we're copying?  Introducing a difference

   // between debug and non-debug behavior seems bad, so I guess not...

   ~nsAbsoluteItems() {

     NS_ASSERTION(!FirstChild(),

                  "Dangling child list.  Someone forgot to insert it?");

   }

 #endif

   // Appends the frame to the end of the list

   void AddChild(nsIFrame* aChild);

 };

 nsAbsoluteItems::nsAbsoluteItems(nsIFrame* aContainingBlock)

   : containingBlock(aContainingBlock)

 {

 }

 // Additional behavior is that it sets the frame's NS_FRAME_OUT_OF_FLOW flag

 void

 nsAbsoluteItems::AddChild(nsIFrame* aChild)

 {

   NS_ASSERTION(aChild->PresContext()->FrameManager()->

                GetPlaceholderFrameFor(aChild),

                "Child without placeholder being added to nsAbsoluteItems?");

   aChild->AddStateBits(NS_FRAME_OUT_OF_FLOW);

   nsFrameItems::AddChild(aChild);

 }

 // -----------------------------------------------------------

 // Structure for saving the existing state when pushing/poping containing

 // blocks. The destructor restores the state to its previous state

 class MOZ_STACK_CLASS nsFrameConstructorSaveState {

 public:

   typedef nsIFrame::ChildListID ChildListID;

   nsFrameConstructorSaveState();

   ~nsFrameConstructorSaveState();

 private:

   nsAbsoluteItems* mItems;      // pointer to struct whose data we save/restore

   nsAbsoluteItems  mSavedItems; // copy of original data

   // The name of the child list in which our frames would belong

   ChildListID mChildListID;

   nsFrameConstructorState* mState;

   // State used only when we're saving the abs-pos state for a transformed

   // element.

   nsAbsoluteItems mSavedFixedItems;

   bool mSavedFixedPosIsAbsPos;

   friend class nsFrameConstructorState;

 };

 // Structure used to keep track of a list of bindings we need to call

 // AddToAttachedQueue on.  These should be in post-order depth-first

 // flattened tree traversal order.

 struct PendingBinding : public LinkedListElement<PendingBinding>

 {

 #ifdef NS_BUILD_REFCNT_LOGGING

   PendingBinding() {

     MOZ_COUNT_CTOR(PendingBinding);

   }

   ~PendingBinding() {

     MOZ_COUNT_DTOR(PendingBinding);

   }

 #endif

   nsRefPtr<nsXBLBinding> mBinding;

 };

 // Structure used for maintaining state information during the

 // frame construction process

 class MOZ_STACK_CLASS nsFrameConstructorState {

 public:

   typedef nsIFrame::ChildListID ChildListID;

   nsPresContext            *mPresContext;

   nsIPresShell             *mPresShell;

   nsFrameManager           *mFrameManager;

 #ifdef MOZ_XUL

   // Frames destined for the kPopupList.

   nsAbsoluteItems           mPopupItems;

 #endif

   // Containing block information for out-of-flow frames.

   nsAbsoluteItems           mFixedItems;

   nsAbsoluteItems           mAbsoluteItems;

   nsAbsoluteItems           mFloatedItems;

   nsCOMPtr<nsILayoutHistoryState> mFrameState;

   // These bits will be added to the state bits of any frame we construct

   // using this state.

   nsFrameState              mAdditionalStateBits;

   // When working with the -moz-transform property, we want to hook

   // the abs-pos and fixed-pos lists together, since transformed

   // elements are fixed-pos containing blocks.  This flag determines

   // whether or not we want to wire the fixed-pos and abs-pos lists

   // together.

   bool                      mFixedPosIsAbsPos;

   // A boolean to indicate whether we have a "pending" popupgroup.  That is, we

   // have already created the FrameConstructionItem for the root popupgroup but

   // we have not yet created the relevant frame.

   bool                      mHavePendingPopupgroup;

   // If false (which is the default) then call SetPrimaryFrame() as needed

   // during frame construction.  If true, don't make any SetPrimaryFrame()

   // calls, except for generated content which doesn't have a primary frame

   // yet.  The mCreatingExtraFrames == true mode is meant to be used for

   // construction of random "extra" frames for elements via normal frame

   // construction APIs (e.g. replication of things across pages in paginated

   // mode).

   bool                      mCreatingExtraFrames;

   nsCOMArray<nsIContent>    mGeneratedTextNodesWithInitializer;

   TreeMatchContext          mTreeMatchContext;

   // Constructor

   // Use the passed-in history state.

   nsFrameConstructorState(nsIPresShell*          aPresShell,

                           nsIFrame*              aFixedContainingBlock,

                           nsIFrame*              aAbsoluteContainingBlock,

                           nsIFrame*              aFloatContainingBlock,

                           nsILayoutHistoryState* aHistoryState);

   // Get the history state from the pres context's pres shell.

   nsFrameConstructorState(nsIPresShell*          aPresShell,

                           nsIFrame*              aFixedContainingBlock,

                           nsIFrame*              aAbsoluteContainingBlock,

                           nsIFrame*              aFloatContainingBlock);

   ~nsFrameConstructorState();

   // Function to push the existing absolute containing block state and

   // create a new scope. Code that uses this function should get matching

   // logic in GetAbsoluteContainingBlock.

   // Also makes aNewAbsoluteContainingBlock the containing block for

   // fixed-pos elements if necessary.

   // aPositionedFrame is the frame whose style actually makes

   // aNewAbsoluteContainingBlock a containing block. E.g. for a scrollable element

   // aPositionedFrame is the element's primary frame and

   // aNewAbsoluteContainingBlock is the scrolled frame.

   void PushAbsoluteContainingBlock(nsIFrame* aNewAbsoluteContainingBlock,

                                    nsIFrame* aPositionedFrame,

                                    nsFrameConstructorSaveState& aSaveState);

   // Function to push the existing float containing block state and

   // create a new scope. Code that uses this function should get matching

   // logic in GetFloatContainingBlock.

   // Pushing a null float containing block forbids any frames from being

   // floated until a new float containing block is pushed.

   // XXX we should get rid of null float containing blocks and teach the

   // various frame classes to deal with floats instead.

   void PushFloatContainingBlock(nsIFrame* aNewFloatContainingBlock,

                                 nsFrameConstructorSaveState& aSaveState);

   // Function to return the proper geometric parent for a frame with display

   // struct given by aStyleDisplay and parent's frame given by

   // aContentParentFrame.

   nsIFrame* GetGeometricParent(const nsStyleDisplay* aStyleDisplay,

                                nsIFrame* aContentParentFrame) const;

   /**

    * Function to add a new frame to the right frame list.  This MUST be called

    * on frames before their children have been processed if the frames might

    * conceivably be out-of-flow; otherwise cleanup in error cases won't work

    * right.  Also, this MUST be called on frames after they have been

    * initialized.

    * @param aNewFrame the frame to add

    * @param aFrameItems the list to add in-flow frames to

    * @param aContent the content pointer for aNewFrame

    * @param aStyleContext the style context resolved for aContent

    * @param aParentFrame the parent frame for the content if it were in-flow

    * @param aCanBePositioned pass false if the frame isn't allowed to be

    *        positioned

    * @param aCanBeFloated pass false if the frame isn't allowed to be

    *        floated

    * @param aIsOutOfFlowPopup pass true if the frame is an out-of-flow popup

    *        (XUL-only)

    */

   void AddChild(nsIFrame* aNewFrame,

                 nsFrameItems& aFrameItems,

                 nsIContent* aContent,

                 nsStyleContext* aStyleContext,

                 nsIFrame* aParentFrame,

                 bool aCanBePositioned = true,

                 bool aCanBeFloated = true,

                 bool aIsOutOfFlowPopup = false,

                 bool aInsertAfter = false,

                 nsIFrame* aInsertAfterFrame = nullptr);

   /**

    * Function to return the fixed-pos element list.  Normally this will just hand back the

    * fixed-pos element list, but in case we're dealing with a transformed element that's

    * acting as an abs-pos and fixed-pos container, we'll hand back the abs-pos list.  Callers should

    * use this function if they want to get the list acting as the fixed-pos item parent.

    */

   nsAbsoluteItems& GetFixedItems()

   {

     return mFixedPosIsAbsPos ? mAbsoluteItems : mFixedItems;

   }

   const nsAbsoluteItems& GetFixedItems() const

   {

     return mFixedPosIsAbsPos ? mAbsoluteItems : mFixedItems;

   }

   /**

    * class to automatically push and pop a pending binding in the frame

    * constructor state.  See nsCSSFrameConstructor::FrameConstructionItem

    * mPendingBinding documentation.

    */

   class PendingBindingAutoPusher;

   friend class PendingBindingAutoPusher;

   class MOZ_STACK_CLASS PendingBindingAutoPusher {

   public:

     PendingBindingAutoPusher(nsFrameConstructorState& aState,

                              PendingBinding* aPendingBinding) :

       mState(aState),

       mPendingBinding(aState.mCurrentPendingBindingInsertionPoint)

         {

           if (aPendingBinding) {

             aState.mCurrentPendingBindingInsertionPoint = aPendingBinding;

           }

         }

     ~PendingBindingAutoPusher()

       {

         mState.mCurrentPendingBindingInsertionPoint = mPendingBinding;

       }

   private:

     nsFrameConstructorState& mState;

     PendingBinding* mPendingBinding;

   };

   /**

    * Add a new pending binding to the list

    */

   void AddPendingBinding(PendingBinding* aPendingBinding) {

     if (mCurrentPendingBindingInsertionPoint) {

       mCurrentPendingBindingInsertionPoint->setPrevious(aPendingBinding);

     } else {

       mPendingBindings.insertBack(aPendingBinding);

     }

   }

 protected:

   friend class nsFrameConstructorSaveState;

   /**

    * ProcessFrameInsertions takes the frames in aFrameItems and adds them as

    * kids to the aChildListID child list of |aFrameItems.containingBlock|.

    */

   void ProcessFrameInsertions(nsAbsoluteItems& aFrameItems,

                               ChildListID aChildListID);

   // Our list of all pending bindings.  When we're done, we need to call

   // AddToAttachedQueue on all of them, in order.

   LinkedList<PendingBinding> mPendingBindings;

   PendingBinding* mCurrentPendingBindingInsertionPoint;

 };

 nsFrameConstructorState::nsFrameConstructorState(nsIPresShell*          aPresShell,

                                                  nsIFrame*              aFixedContainingBlock,

                                                  nsIFrame*              aAbsoluteContainingBlock,

                                                  nsIFrame*              aFloatContainingBlock,

                                                  nsILayoutHistoryState* aHistoryState)

   : mPresContext(aPresShell->GetPresContext()),

     mPresShell(aPresShell),

     mFrameManager(aPresShell->FrameManager()),

 #ifdef MOZ_XUL

     mPopupItems(nullptr),

 #endif

     mFixedItems(aFixedContainingBlock),

     mAbsoluteItems(aAbsoluteContainingBlock),

     mFloatedItems(aFloatContainingBlock),

     // See PushAbsoluteContaningBlock below

     mFrameState(aHistoryState),

     mAdditionalStateBits(nsFrameState(0)),

     // If the fixed-pos containing block is equal to the abs-pos containing

     // block, use the abs-pos containing block's abs-pos list for fixed-pos

 	// frames.

     mFixedPosIsAbsPos(aFixedContainingBlock == aAbsoluteContainingBlock),

     mHavePendingPopupgroup(false),

     mCreatingExtraFrames(false),

     mTreeMatchContext(true, nsRuleWalker::eRelevantLinkUnvisited,

                       aPresShell->GetDocument()),

     mCurrentPendingBindingInsertionPoint(nullptr)

 {

 #ifdef MOZ_XUL

   nsIRootBox* rootBox = nsIRootBox::GetRootBox(aPresShell);

   if (rootBox) {

     mPopupItems.containingBlock = rootBox->GetPopupSetFrame();

   }

 #endif

   MOZ_COUNT_CTOR(nsFrameConstructorState);

 }

 nsFrameConstructorState::nsFrameConstructorState(nsIPresShell* aPresShell,

                                                  nsIFrame*     aFixedContainingBlock,

                                                  nsIFrame*     aAbsoluteContainingBlock,

                                                  nsIFrame*     aFloatContainingBlock)

   : mPresContext(aPresShell->GetPresContext()),

     mPresShell(aPresShell),

     mFrameManager(aPresShell->FrameManager()),

 #ifdef MOZ_XUL

     mPopupItems(nullptr),

 #endif

     mFixedItems(aFixedContainingBlock),

     mAbsoluteItems(aAbsoluteContainingBlock),

     mFloatedItems(aFloatContainingBlock),

     // See PushAbsoluteContaningBlock below

     mAdditionalStateBits(nsFrameState(0)),

     // If the fixed-pos containing block is equal to the abs-pos containing

     // block, use the abs-pos containing block's abs-pos list for fixed-pos

 	// frames.

     mFixedPosIsAbsPos(aFixedContainingBlock == aAbsoluteContainingBlock),

     mHavePendingPopupgroup(false),

     mCreatingExtraFrames(false),

     mTreeMatchContext(true, nsRuleWalker::eRelevantLinkUnvisited,

                       aPresShell->GetDocument()),

     mCurrentPendingBindingInsertionPoint(nullptr)

 {

 #ifdef MOZ_XUL

   nsIRootBox* rootBox = nsIRootBox::GetRootBox(aPresShell);

   if (rootBox) {

     mPopupItems.containingBlock = rootBox->GetPopupSetFrame();

   }

 #endif

   MOZ_COUNT_CTOR(nsFrameConstructorState);

   mFrameState = aPresShell->GetDocument()->GetLayoutHistoryState();

 }

 nsFrameConstructorState::~nsFrameConstructorState()

 {

   // Frame order comparison functions only work properly when the placeholders

   // have been inserted into the frame tree. So for example if we have a new float

   // containing the placeholder for a new abs-pos frame, and we process the abs-pos

   // insertion first, then we won't be able to find the right place to insert in

   // in the abs-pos list. So put floats in first, because they can contain placeholders

   // for abs-pos and fixed-pos items whose containing blocks are outside the floats.

   // Then put abs-pos frames in, because they can contain placeholders for fixed-pos

   // items whose containing block is outside the abs-pos frames.

   MOZ_COUNT_DTOR(nsFrameConstructorState);

   ProcessFrameInsertions(mFloatedItems, nsIFrame::kFloatList);

   ProcessFrameInsertions(mAbsoluteItems, nsIFrame::kAbsoluteList);

   ProcessFrameInsertions(mFixedItems, nsIFrame::kFixedList);

 #ifdef MOZ_XUL

   ProcessFrameInsertions(mPopupItems, nsIFrame::kPopupList);

 #endif

   for (int32_t i = mGeneratedTextNodesWithInitializer.Count() - 1; i >= 0; --i) {

     mGeneratedTextNodesWithInitializer[i]->

       DeleteProperty(nsGkAtoms::genConInitializerProperty);

   }

   if (!mPendingBindings.isEmpty()) {

     nsBindingManager* bindingManager = mPresShell->GetDocument()->BindingManager();

     do {

       nsAutoPtr<PendingBinding> pendingBinding;

       pendingBinding = mPendingBindings.popFirst();

       bindingManager->AddToAttachedQueue(pendingBinding->mBinding);

     } while (!mPendingBindings.isEmpty());

     mCurrentPendingBindingInsertionPoint = nullptr;

   }

 }

 static nsIFrame*

 AdjustAbsoluteContainingBlock(nsIFrame* aContainingBlockIn)

 {

   if (!aContainingBlockIn) {

     return nullptr;

   }

   // Always use the container's first continuation. (Inline frames can have

   // non-fluid bidi continuations...)

   return aContainingBlockIn->FirstContinuation();

 }

 void

 nsFrameConstructorState::PushAbsoluteContainingBlock(nsIFrame* aNewAbsoluteContainingBlock,

                                                      nsIFrame* aPositionedFrame,

                                                      nsFrameConstructorSaveState& aSaveState)

 {

   aSaveState.mItems = &mAbsoluteItems;

   aSaveState.mSavedItems = mAbsoluteItems;

   aSaveState.mChildListID = nsIFrame::kAbsoluteList;

   aSaveState.mState = this;

   aSaveState.mSavedFixedPosIsAbsPos = mFixedPosIsAbsPos;

   if (mFixedPosIsAbsPos) {

     // Since we're going to replace mAbsoluteItems, we need to save it into

     // mFixedItems now (and save the current value of mFixedItems).

     aSaveState.mSavedFixedItems = mFixedItems;

     mFixedItems = mAbsoluteItems;

   }

   mAbsoluteItems =

     nsAbsoluteItems(AdjustAbsoluteContainingBlock(aNewAbsoluteContainingBlock));

   /* See if we're wiring the fixed-pos and abs-pos lists together.  This happens iff

    * we're a transformed element.

    */

   mFixedPosIsAbsPos = aPositionedFrame &&

       (aPositionedFrame->StyleDisplay()->HasTransform(aPositionedFrame) ||

        aPositionedFrame->StyleDisplay()->HasPerspectiveStyle());

   if (aNewAbsoluteContainingBlock) {

     aNewAbsoluteContainingBlock->MarkAsAbsoluteContainingBlock();

   }

 }

 void

 nsFrameConstructorState::PushFloatContainingBlock(nsIFrame* aNewFloatContainingBlock,

                                                   nsFrameConstructorSaveState& aSaveState)

 {

   NS_PRECONDITION(!aNewFloatContainingBlock ||

                   aNewFloatContainingBlock->IsFloatContainingBlock(),

                   "Please push a real float containing block!");

   NS_ASSERTION(!aNewFloatContainingBlock ||

                !ShouldSuppressFloatingOfDescendants(aNewFloatContainingBlock),

                "We should not push a frame that is supposed to _suppress_ "

                "floats as a float containing block!");

   aSaveState.mItems = &mFloatedItems;

   aSaveState.mSavedItems = mFloatedItems;

   aSaveState.mChildListID = nsIFrame::kFloatList;

   aSaveState.mState = this;

   mFloatedItems = nsAbsoluteItems(aNewFloatContainingBlock);

 }

 nsIFrame*

 nsFrameConstructorState::GetGeometricParent(const nsStyleDisplay* aStyleDisplay,

                                             nsIFrame* aContentParentFrame) const

 {

   NS_PRECONDITION(aStyleDisplay, "Must have display struct!");

   // If there is no container for a fixed, absolute, or floating root

   // frame, we will ignore the positioning.  This hack is originally

   // brought to you by the letter T: tables, since other roots don't

   // even call into this code.  See bug 178855.

   //

   // XXX Disabling positioning in this case is a hack.  If one was so inclined,

   // one could support this either by (1) inserting a dummy block between the

   // table and the canvas or (2) teaching the canvas how to reflow positioned

   // elements. (1) has the usual problems when multiple frames share the same

   // content (notice all the special cases in this file dealing with inner

   // tables and outer tables which share the same content). (2) requires some

   // work and possible factoring.

   //

   // XXXbz couldn't we just force position to "static" on roots and

   // float to "none"?  That's OK per CSS 2.1, as far as I can tell.

   if (aContentParentFrame && aContentParentFrame->IsSVGText()) {

     return aContentParentFrame;

   }

   if (aStyleDisplay->IsFloatingStyle() && mFloatedItems.containingBlock) {

     NS_ASSERTION(!aStyleDisplay->IsAbsolutelyPositionedStyle(),

                  "Absolutely positioned _and_ floating?");

     return mFloatedItems.containingBlock;

   }

   if (aStyleDisplay->mPosition == NS_STYLE_POSITION_ABSOLUTE &&

       mAbsoluteItems.containingBlock) {

     return mAbsoluteItems.containingBlock;

   }

   if (aStyleDisplay->mPosition == NS_STYLE_POSITION_FIXED &&

       GetFixedItems().containingBlock) {

     return GetFixedItems().containingBlock;

   }

   return aContentParentFrame;

 }

 void

 nsFrameConstructorState::AddChild(nsIFrame* aNewFrame,

                                   nsFrameItems& aFrameItems,

                                   nsIContent* aContent,

                                   nsStyleContext* aStyleContext,

                                   nsIFrame* aParentFrame,

                                   bool aCanBePositioned,

                                   bool aCanBeFloated,

                                   bool aIsOutOfFlowPopup,

                                   bool aInsertAfter,

                                   nsIFrame* aInsertAfterFrame)

 {

   NS_PRECONDITION(!aNewFrame->GetNextSibling(), "Shouldn't happen");

   const nsStyleDisplay* disp = aNewFrame->StyleDisplay();

   // The comments in GetGeometricParent regarding root table frames

   // all apply here, unfortunately.

   bool needPlaceholder = false;

   nsFrameState placeholderType;

   nsFrameItems* frameItems = &aFrameItems;

 #ifdef MOZ_XUL

   if (MOZ_UNLIKELY(aIsOutOfFlowPopup)) {

       NS_ASSERTION(aNewFrame->GetParent() == mPopupItems.containingBlock,

                    "Popup whose parent is not the popup containing block?");

       NS_ASSERTION(mPopupItems.containingBlock, "Must have a popup set frame!");

       needPlaceholder = true;

       frameItems = &mPopupItems;

       placeholderType = PLACEHOLDER_FOR_POPUP;

   }

   else

 #endif // MOZ_XUL

   if (aCanBeFloated && aNewFrame->IsFloating() &&

       mFloatedItems.containingBlock) {

     NS_ASSERTION(aNewFrame->GetParent() == mFloatedItems.containingBlock,

                  "Float whose parent is not the float containing block?");

     needPlaceholder = true;

     frameItems = &mFloatedItems;

     placeholderType = PLACEHOLDER_FOR_FLOAT;

   }

   else if (aCanBePositioned) {

     if (disp->mPosition == NS_STYLE_POSITION_ABSOLUTE &&

         mAbsoluteItems.containingBlock) {

       NS_ASSERTION(aNewFrame->GetParent() == mAbsoluteItems.containingBlock,

                    "Abs pos whose parent is not the abs pos containing block?");

       needPlaceholder = true;

       frameItems = &mAbsoluteItems;

       placeholderType = PLACEHOLDER_FOR_ABSPOS;

     }

     if (disp->mPosition == NS_STYLE_POSITION_FIXED &&

         GetFixedItems().containingBlock) {

       NS_ASSERTION(aNewFrame->GetParent() == GetFixedItems().containingBlock,

                    "Fixed pos whose parent is not the fixed pos containing block?");

       needPlaceholder = true;

       frameItems = &GetFixedItems();

       placeholderType = PLACEHOLDER_FOR_FIXEDPOS;

     }

   }

   if (needPlaceholder) {

     NS_ASSERTION(frameItems != &aFrameItems,

                  "Putting frame in-flow _and_ want a placeholder?");

     nsIFrame* placeholderFrame =

       nsCSSFrameConstructor::CreatePlaceholderFrameFor(mPresShell,

                                                        aContent,

                                                        aNewFrame,

                                                        aStyleContext,

                                                        aParentFrame,

                                                        nullptr,

                                                        placeholderType);

     placeholderFrame->AddStateBits(mAdditionalStateBits);

     // Add the placeholder frame to the flow

     aFrameItems.AddChild(placeholderFrame);

   }

 #ifdef DEBUG

   else {

     NS_ASSERTION(aNewFrame->GetParent() == aParentFrame,

                  "In-flow frame has wrong parent");

   }

 #endif

   if (aInsertAfter) {

     frameItems->InsertFrame(nullptr, aInsertAfterFrame, aNewFrame);

   } else {

     frameItems->AddChild(aNewFrame);

   }

 }

 void

 nsFrameConstructorState::ProcessFrameInsertions(nsAbsoluteItems& aFrameItems,

                                                 ChildListID aChildListID)

 {

 #define NS_NONXUL_LIST_TEST (&aFrameItems == &mFloatedItems &&            \

                              aChildListID == nsIFrame::kFloatList)    ||  \

                             (&aFrameItems == &mAbsoluteItems &&           \

                              aChildListID == nsIFrame::kAbsoluteList) ||  \

                             (&aFrameItems == &mFixedItems &&              \

                              aChildListID == nsIFrame::kFixedList)

 #ifdef MOZ_XUL

   NS_PRECONDITION(NS_NONXUL_LIST_TEST ||

                   (&aFrameItems == &mPopupItems &&

                    aChildListID == nsIFrame::kPopupList),

                   "Unexpected aFrameItems/aChildListID combination");

 #else

   NS_PRECONDITION(NS_NONXUL_LIST_TEST,

                   "Unexpected aFrameItems/aChildListID combination");

 #endif

   if (aFrameItems.IsEmpty()) {

     return;

   }

   nsIFrame* containingBlock = aFrameItems.containingBlock;

   NS_ASSERTION(containingBlock,

                "Child list without containing block?");

   if (aChildListID == nsIFrame::kFixedList) {

     // Put this frame on the transformed-frame's abs-pos list instead, if

     // it has abs-pos children instead of fixed-pos children.

     aChildListID = containingBlock->GetAbsoluteListID();

   }

   // Insert the frames hanging out in aItems.  We can use SetInitialChildList()

   // if the containing block hasn't been reflowed yet (so NS_FRAME_FIRST_REFLOW

   // is set) and doesn't have any frames in the aChildListID child list yet.

   const nsFrameList& childList = containingBlock->GetChildList(aChildListID);

   DebugOnly<nsresult> rv = NS_OK;

   if (childList.IsEmpty() &&

       (containingBlock->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {

     // If we're injecting absolutely positioned frames, inject them on the

     // absolute containing block

     if (aChildListID == containingBlock->GetAbsoluteListID()) {

       rv = containingBlock->GetAbsoluteContainingBlock()->

            SetInitialChildList(containingBlock, aChildListID, aFrameItems);

     } else {

       rv = containingBlock->SetInitialChildList(aChildListID, aFrameItems);

     }

   } else {

     // Note that whether the frame construction context is doing an append or

     // not is not helpful here, since it could be appending to some frame in

     // the middle of the document, which means we're not necessarily

     // appending to the children of the containing block.

     //

     // We need to make sure the 'append to the end of document' case is fast.

     // So first test the last child of the containing block

     nsIFrame* lastChild = childList.LastChild();

     // CompareTreePosition uses placeholder hierarchy for out of flow frames,

     // so this will make out-of-flows respect the ordering of placeholders,

     // which is great because it takes care of anonymous content.

     nsIFrame* firstNewFrame = aFrameItems.FirstChild();

     // Cache the ancestor chain so that we can reuse it if needed.

     nsAutoTArray<nsIFrame*, 20> firstNewFrameAncestors;

     nsIFrame* notCommonAncestor = nullptr;

     if (lastChild) {

       notCommonAncestor = nsLayoutUtils::FillAncestors(firstNewFrame,

                                                        containingBlock,

                                                        &firstNewFrameAncestors);

     }

     if (!lastChild ||

         nsLayoutUtils::CompareTreePosition(lastChild, firstNewFrame,

                                            firstNewFrameAncestors,

                                            notCommonAncestor ?

                                              containingBlock : nullptr) < 0) {

       // no lastChild, or lastChild comes before the new children, so just append

       rv = mFrameManager->AppendFrames(containingBlock, aChildListID, aFrameItems);

     } else {

       // Try the other children. First collect them to an array so that a

       // reasonable fast binary search can be used to find the insertion point.

       nsAutoTArray<nsIFrame*, 128> children;

       for (nsIFrame* f = childList.FirstChild(); f != lastChild;

            f = f->GetNextSibling()) {

         children.AppendElement(f);

       }

       nsIFrame* insertionPoint = nullptr;

       int32_t imin = 0;

       int32_t max = children.Length();

       while (max > imin) {

         int32_t imid = imin + ((max - imin) / 2);

         nsIFrame* f = children[imid];

         int32_t compare =

           nsLayoutUtils::CompareTreePosition(f, firstNewFrame, firstNewFrameAncestors,

                                              notCommonAncestor ? containingBlock : nullptr);

         if (compare > 0) {

           // f is after the new frame.

           max = imid;

           insertionPoint = imid > 0 ? children[imid - 1] : nullptr;

         } else if (compare < 0) {

           // f is before the new frame.

           imin = imid + 1;

           insertionPoint = f;

         } else {

           // This is for the old behavior. Should be removed once it is

           // guaranteed that CompareTreePosition can't return 0!

           // See bug 928645.

           NS_WARNING("Something odd happening???");

           insertionPoint = nullptr;

           for (uint32_t i = 0; i < children.Length(); ++i) {

             nsIFrame* f = children[i];

             if (nsLayoutUtils::CompareTreePosition(f, firstNewFrame,

                                                    firstNewFrameAncestors,

                                                    notCommonAncestor ?

                                                      containingBlock : nullptr) > 0) {

               break;

             }

             insertionPoint = f;

           }

           break;

         }

       }

       rv = mFrameManager->InsertFrames(containingBlock, aChildListID,

                                        insertionPoint, aFrameItems);

     }

   }

   NS_POSTCONDITION(aFrameItems.IsEmpty(), "How did that happen?");

   // XXXbz And if NS_FAILED(rv), what?  I guess we need to clean up the list

   // and deal with all the placeholders... but what if the placeholders aren't

   // in the document yet?  Could that happen?

   NS_ASSERTION(NS_SUCCEEDED(rv), "Frames getting lost!");

 }

 nsFrameConstructorSaveState::nsFrameConstructorSaveState()

   : mItems(nullptr),

     mSavedItems(nullptr),

     mChildListID(kPrincipalList),

     mState(nullptr),

     mSavedFixedItems(nullptr),

     mSavedFixedPosIsAbsPos(false)

 {

 }

 nsFrameConstructorSaveState::~nsFrameConstructorSaveState()

 {

   // Restore the state

   if (mItems) {

     NS_ASSERTION(mState, "Can't have mItems set without having a state!");

     mState->ProcessFrameInsertions(*mItems, mChildListID);

     *mItems = mSavedItems;

 #ifdef DEBUG

     // We've transferred the child list, so drop the pointer we held to it.

     // Note that this only matters for the assert in ~nsAbsoluteItems.

     mSavedItems.Clear();

 #endif

     if (mItems == &mState->mAbsoluteItems) {

       mState->mFixedPosIsAbsPos = mSavedFixedPosIsAbsPos;

       if (mSavedFixedPosIsAbsPos) {

         // mAbsoluteItems was moved to mFixedItems, so move mFixedItems back

         // and repair the old mFixedItems now.

         mState->mAbsoluteItems = mState->mFixedItems;

         mState->mFixedItems = mSavedFixedItems;

 #ifdef DEBUG

         mSavedFixedItems.Clear();

 #endif

       }

     }

     NS_ASSERTION(!mItems->LastChild() || !mItems->LastChild()->GetNextSibling(),

                  "Something corrupted our list");

   }

 }

 static

 bool IsBorderCollapse(nsIFrame* aFrame)

 {

   for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {

     if (nsGkAtoms::tableFrame == frame->GetType()) {

       return ((nsTableFrame*)frame)->IsBorderCollapse();

     }

   }

   NS_ASSERTION(false, "program error");

   return false;

 }

 /**

  * Moves aFrameList from aOldParent to aNewParent.  This updates the parent

  * pointer of the frames in the list, and reparents their views as needed.

  * nsFrame::SetParent sets the NS_FRAME_HAS_VIEW bit on aNewParent and its

  * ancestors as needed. Then it sets the list as the initial child list

  * on aNewParent, unless aNewParent either already has kids or has been

  * reflowed; in that case it appends the new frames.  Note that this

  * method differs from ReparentFrames in that it doesn't change the kids'

  * style contexts.

  */

 // XXXbz Since this is only used for {ib} splits, could we just copy the view

 // bits from aOldParent to aNewParent and then use the

 // nsFrameList::ApplySetParent?  That would still leave us doing two passes

 // over the list, of course; if we really wanted to we could factor out the

 // relevant part of ReparentFrameViewList, I suppose...  Or just get rid of

 // views, which would make most of this function go away.

 static void

 MoveChildrenTo(nsPresContext* aPresContext,

                nsIFrame* aOldParent,

                nsIFrame* aNewParent,

                nsFrameList& aFrameList)

 {

   bool sameGrandParent = aOldParent->GetParent() == aNewParent->GetParent();

   if (aNewParent->HasView() || aOldParent->HasView() || !sameGrandParent) {

     // Move the frames into the new view

     nsContainerFrame::ReparentFrameViewList(aFrameList, aOldParent, aNewParent);

   }

   for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {

     e.get()->SetParent(aNewParent);

   }

   if (aNewParent->PrincipalChildList().IsEmpty() &&

       (aNewParent->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {

     aNewParent->SetInitialChildList(kPrincipalList, aFrameList);

   } else {

     aNewParent->AppendFrames(kPrincipalList, aFrameList);

   }

 }

 //----------------------------------------------------------------------

 nsCSSFrameConstructor::nsCSSFrameConstructor(nsIDocument *aDocument,

                                              nsIPresShell *aPresShell,

                                              nsStyleSet* aStyleSet)

   : nsFrameManager(aPresShell, aStyleSet)

   , mDocument(aDocument)

   , mRootElementFrame(nullptr)

   , mRootElementStyleFrame(nullptr)

   , mFixedContainingBlock(nullptr)

   , mDocElementContainingBlock(nullptr)

   , mGfxScrollFrame(nullptr)

   , mPageSequenceFrame(nullptr)

   , mCurrentDepth(0)

   , mUpdateCount(0)

   , mQuotesDirty(false)

   , mCountersDirty(false)

   , mIsDestroyingFrameTree(false)

   , mHasRootAbsPosContainingBlock(false)

   , mAlwaysCreateFramesForIgnorableWhitespace(false)

 {

 #ifdef DEBUG

   static bool gFirstTime = true;

   if (gFirstTime) {

     gFirstTime = false;

     char* flags = PR_GetEnv("GECKO_FRAMECTOR_DEBUG_FLAGS");

     if (flags) {

       bool error = false;

       for (;;) {

         char* comma = PL_strchr(flags, ',');

         if (comma)

           *comma = '\0';

         bool found = false;

         FrameCtorDebugFlags* flag = gFlags;

         FrameCtorDebugFlags* limit = gFlags + NUM_DEBUG_FLAGS;

         while (flag < limit) {

           if (PL_strcasecmp(flag->name, flags) == 0) {

             *(flag->on) = true;

             printf("nsCSSFrameConstructor: setting %s debug flag on\n", flag->name);

             found = true;

             break;

           }

           ++flag;

         }

         if (! found)

           error = true;

         if (! comma)

           break;

         *comma = ',';

         flags = comma + 1;

       }

       if (error) {

         printf("Here are the available GECKO_FRAMECTOR_DEBUG_FLAGS:\n");

         FrameCtorDebugFlags* flag = gFlags;

         FrameCtorDebugFlags* limit = gFlags + NUM_DEBUG_FLAGS;

         while (flag < limit) {

           printf("  %s\n", flag->name);

           ++flag;

         }

         printf("Note: GECKO_FRAMECTOR_DEBUG_FLAGS is a comma separated list of flag\n");

         printf("names (no whitespace)\n");

       }

     }

   }

 #endif

 }

 void

 nsCSSFrameConstructor::NotifyDestroyingFrame(nsIFrame* aFrame)

 {

   NS_PRECONDITION(mUpdateCount != 0,

                   "Should be in an update while destroying frames");

   if (aFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT) {

     if (mQuoteList.DestroyNodesFor(aFrame))

       QuotesDirty();

   }

   if (mCounterManager.DestroyNodesFor(aFrame)) {

     // Technically we don't need to update anything if we destroyed only

     // USE nodes.  However, this is unlikely to happen in the real world

     // since USE nodes generally go along with INCREMENT nodes.

     CountersDirty();

   }

   RestyleManager()->NotifyDestroyingFrame(aFrame);

   nsFrameManager::NotifyDestroyingFrame(aFrame);

 }

 struct nsGenConInitializer {

   nsAutoPtr<nsGenConNode> mNode;

   nsGenConList*           mList;

   void (nsCSSFrameConstructor::*mDirtyAll)();

   nsGenConInitializer(nsGenConNode* aNode, nsGenConList* aList,

                       void (nsCSSFrameConstructor::*aDirtyAll)())

     : mNode(aNode), mList(aList), mDirtyAll(aDirtyAll) {}

 };

 already_AddRefed<nsIContent>

 nsCSSFrameConstructor::CreateGenConTextNode(nsFrameConstructorState& aState,

                                             const nsString& aString,

                                             nsCOMPtr<nsIDOMCharacterData>* aText,

                                             nsGenConInitializer* aInitializer)

 {

   nsRefPtr<nsTextNode> content = new nsTextNode(mDocument->NodeInfoManager());

   content->SetText(aString, false);

   if (aText) {

     *aText = content;

   }

   if (aInitializer) {

     content->SetProperty(nsGkAtoms::genConInitializerProperty, aInitializer,

                          nsINode::DeleteProperty<nsGenConInitializer>);

     aState.mGeneratedTextNodesWithInitializer.AppendObject(content);

   }

   return content.forget();

 }

 already_AddRefed<nsIContent>

 nsCSSFrameConstructor::CreateGeneratedContent(nsFrameConstructorState& aState,

                                               nsIContent*     aParentContent,

                                               nsStyleContext* aStyleContext,

                                               uint32_t        aContentIndex)

 {

   // Get the content value

   const nsStyleContentData &data =

     aStyleContext->StyleContent()->ContentAt(aContentIndex);

   nsStyleContentType type = data.mType;

   if (eStyleContentType_Image == type) {

     if (!data.mContent.mImage) {

       // CSS had something specified that couldn't be converted to an

       // image object

       return nullptr;

     }

     // Create an image content object and pass it the image request.

     // XXX Check if it's an image type we can handle...

     nsCOMPtr<nsINodeInfo> nodeInfo;

     nodeInfo = mDocument->NodeInfoManager()->

       GetNodeInfo(nsGkAtoms::mozgeneratedcontentimage, nullptr,

                   kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE);

     nsCOMPtr<nsIContent> content;

     NS_NewGenConImageContent(getter_AddRefs(content), nodeInfo.forget(),

                              data.mContent.mImage);

     return content.forget();

   }

   switch (type) {

   case eStyleContentType_String:

     return CreateGenConTextNode(aState,

                                 nsDependentString(data.mContent.mString),

                                 nullptr, nullptr);

   case eStyleContentType_Attr:

     {

       nsCOMPtr<nsIAtom> attrName;

       int32_t attrNameSpace = kNameSpaceID_None;

       nsAutoString contentString(data.mContent.mString);

       int32_t barIndex = contentString.FindChar('|'); // CSS namespace delimiter

       if (-1 != barIndex) {

         nsAutoString  nameSpaceVal;

         contentString.Left(nameSpaceVal, barIndex);

         nsresult error;

         attrNameSpace = nameSpaceVal.ToInteger(&error);

         contentString.Cut(0, barIndex + 1);

         if (contentString.Length()) {

           if (mDocument->IsHTML() && aParentContent->IsHTML()) {

             ToLowerCase(contentString);

           }

           attrName = do_GetAtom(contentString);

         }

       }

       else {

         if (mDocument->IsHTML() && aParentContent->IsHTML()) {

           ToLowerCase(contentString);

         }

         attrName = do_GetAtom(contentString);

       }

       if (!attrName) {

         return nullptr;

       }

       nsCOMPtr<nsIContent> content;

       NS_NewAttributeContent(mDocument->NodeInfoManager(),

                              attrNameSpace, attrName, getter_AddRefs(content));

       return content.forget();

     }

   case eStyleContentType_Counter:

   case eStyleContentType_Counters:

     {

       nsCSSValue::Array* counters = data.mContent.mCounters;

       nsCounterList* counterList = mCounterManager.CounterListFor(

           nsDependentString(counters->Item(0).GetStringBufferValue()));

       if (!counterList)

         return nullptr;

       nsCounterUseNode* node =

         new nsCounterUseNode(counters, aContentIndex,

                              type == eStyleContentType_Counters);

       nsGenConInitializer* initializer =

         new nsGenConInitializer(node, counterList,

                                 &nsCSSFrameConstructor::CountersDirty);

       return CreateGenConTextNode(aState, EmptyString(), &node->mText,

                                   initializer);

     }

   case eStyleContentType_Image:

     NS_NOTREACHED("handled by if above");

     return nullptr;

   case eStyleContentType_OpenQuote:

   case eStyleContentType_CloseQuote:

   case eStyleContentType_NoOpenQuote:

   case eStyleContentType_NoCloseQuote:

     {

       nsQuoteNode* node =

         new nsQuoteNode(type, aContentIndex);

       nsGenConInitializer* initializer =

         new nsGenConInitializer(node, &mQuoteList,

                                 &nsCSSFrameConstructor::QuotesDirty);

       return CreateGenConTextNode(aState, EmptyString(), &node->mText,

                                   initializer);

     }

   case eStyleContentType_AltContent:

     {

       // Use the "alt" attribute; if that fails and the node is an HTML

       // <input>, try the value attribute and then fall back to some default

       // localized text we have.

       // XXX what if the 'alt' attribute is added later, how will we

       // detect that and do the right thing here?

       if (aParentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::alt)) {

         nsCOMPtr<nsIContent> content;

         NS_NewAttributeContent(mDocument->NodeInfoManager(),

                                kNameSpaceID_None, nsGkAtoms::alt, getter_AddRefs(content));

         return content.forget();

       }

       if (aParentContent->IsHTML() &&

           aParentContent->NodeInfo()->Equals(nsGkAtoms::input)) {

         if (aParentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::value)) {

           nsCOMPtr<nsIContent> content;

           NS_NewAttributeContent(mDocument->NodeInfoManager(),

                                  kNameSpaceID_None, nsGkAtoms::value, getter_AddRefs(content));

           return content.forget();

         }

         nsXPIDLString temp;

         nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES,

                                            "Submit", temp);

         return CreateGenConTextNode(aState, temp, nullptr, nullptr);

       }

       break;

     }

   case eStyleContentType_Uninitialized:

     NS_NOTREACHED("uninitialized content type");

     return nullptr;

   } // switch

   return nullptr;

 }

 /*

  * aParentFrame - the frame that should be the parent of the generated

  *   content.  This is the frame for the corresponding content node,

  *   which must not be a leaf frame.

  *

  * Any items created are added to aItems.

  *

  * We create an XML element (tag _moz_generated_content_before or

  * _moz_generated_content_after) representing the pseudoelement. We

  * create a DOM node for each 'content' item and make those nodes the

  * children of the XML element. Then we create a frame subtree for

  * the XML element as if it were a regular child of

  * aParentFrame/aParentContent, giving the XML element the ::before or

  * ::after style.

  */

 void

 nsCSSFrameConstructor::CreateGeneratedContentItem(nsFrameConstructorState& aState,

                                                   nsIFrame*        aParentFrame,

                                                   nsIContent*      aParentContent,

                                                   nsStyleContext*  aStyleContext,

                                                   nsCSSPseudoElements::Type aPseudoElement,

                                                   FrameConstructionItemList& aItems)

 {

   // XXXbz is this ever true?

   if (!aParentContent->IsElement()) {

     NS_ERROR("Bogus generated content parent");

     return;

   }

   nsStyleSet *styleSet = mPresShell->StyleSet();

   // Probe for the existence of the pseudo-element

   nsRefPtr<nsStyleContext> pseudoStyleContext;

   pseudoStyleContext =

     styleSet->ProbePseudoElementStyle(aParentContent->AsElement(),

                                       aPseudoElement,

                                       aStyleContext,

                                       aState.mTreeMatchContext);

   if (!pseudoStyleContext)

     return;

   // |ProbePseudoStyleFor| checked the 'display' property and the

   // |ContentCount()| of the 'content' property for us.

   nsCOMPtr<nsINodeInfo> nodeInfo;

   nsIAtom* elemName = aPseudoElement == nsCSSPseudoElements::ePseudo_before ?

     nsGkAtoms::mozgeneratedcontentbefore : nsGkAtoms::mozgeneratedcontentafter;

   nodeInfo = mDocument->NodeInfoManager()->GetNodeInfo(elemName, nullptr,

                                                        kNameSpaceID_None,

                                                        nsIDOMNode::ELEMENT_NODE);

   nsCOMPtr<Element> container;

   nsresult rv = NS_NewXMLElement(getter_AddRefs(container), nodeInfo.forget());

   if (NS_FAILED(rv))

     return;

   container->SetIsNativeAnonymousRoot();

   rv = container->BindToTree(mDocument, aParentContent, aParentContent, true);

   if (NS_FAILED(rv)) {

     container->UnbindFromTree();

     return;

   }

   uint32_t contentCount = pseudoStyleContext->StyleContent()->ContentCount();

   for (uint32_t contentIndex = 0; contentIndex < contentCount; contentIndex++) {

     nsCOMPtr<nsIContent> content =

       CreateGeneratedContent(aState, aParentContent, pseudoStyleContext,

                              contentIndex);

     if (content) {

       container->AppendChildTo(content, false);

     }

   }

   AddFrameConstructionItemsInternal(aState, container, aParentFrame, elemName,

                                     kNameSpaceID_None, true,

                                     pseudoStyleContext,

                                     ITEM_IS_GENERATED_CONTENT, nullptr,

                                     aItems);

 }

 /****************************************************

  **  BEGIN TABLE SECTION

  ****************************************************/

 // The term pseudo frame is being used instead of anonymous frame, since anonymous

 // frame has been used elsewhere to refer to frames that have generated content

 // Return whether the given frame is a table pseudo-frame.  Note that

 // cell-content and table-outer frames have pseudo-types, but are always

 // created, even for non-anonymous cells and tables respectively.  So for those

 // we have to examine the cell or table frame to see whether it's a pseudo

 // frame.  In particular, a lone table caption will have an outer table as its

 // parent, but will also trigger construction of an empty inner table, which

 // will be the one we can examine to see whether the outer was a pseudo-frame.

 static bool

 IsTablePseudo(nsIFrame* aFrame)

 {

   nsIAtom* pseudoType = aFrame->StyleContext()->GetPseudo();

   return pseudoType &&

     (pseudoType == nsCSSAnonBoxes::table ||

      pseudoType == nsCSSAnonBoxes::inlineTable ||

      pseudoType == nsCSSAnonBoxes::tableColGroup ||

      pseudoType == nsCSSAnonBoxes::tableRowGroup ||

      pseudoType == nsCSSAnonBoxes::tableRow ||

      pseudoType == nsCSSAnonBoxes::tableCell ||

      (pseudoType == nsCSSAnonBoxes::cellContent &&

       aFrame->GetParent()->StyleContext()->GetPseudo() ==

         nsCSSAnonBoxes::tableCell) ||

      (pseudoType == nsCSSAnonBoxes::tableOuter &&

       (aFrame->GetFirstPrincipalChild()->StyleContext()->GetPseudo() ==

          nsCSSAnonBoxes::table ||

        aFrame->GetFirstPrincipalChild()->StyleContext()->GetPseudo() ==

          nsCSSAnonBoxes::inlineTable)));

 }

 /* static */

 nsCSSFrameConstructor::ParentType

 nsCSSFrameConstructor::GetParentType(nsIAtom* aFrameType)

 {

   if (aFrameType == nsGkAtoms::tableFrame) {

     return eTypeTable;

   }

   if (aFrameType == nsGkAtoms::tableRowGroupFrame) {

     return eTypeRowGroup;

   }

   if (aFrameType == nsGkAtoms::tableRowFrame) {

     return eTypeRow;

   }

   if (aFrameType == nsGkAtoms::tableColGroupFrame) {

     return eTypeColGroup;

   }

   return eTypeBlock;

 }

 static nsIFrame*

 AdjustCaptionParentFrame(nsIFrame* aParentFrame)

 {

   if (nsGkAtoms::tableFrame == aParentFrame->GetType()) {

     return aParentFrame->GetParent();;

   }

   return aParentFrame;

 }

 /**

  * If the parent frame is a |tableFrame| and the child is a

  * |captionFrame|, then we want to insert the frames beneath the

  * |tableFrame|'s parent frame. Returns |true| if the parent frame

  * needed to be fixed up.

  */

 static bool

 GetCaptionAdjustedParent(nsIFrame*        aParentFrame,

                          const nsIFrame*  aChildFrame,

                          nsIFrame**       aAdjParentFrame)

 {

   *aAdjParentFrame = aParentFrame;

   bool haveCaption = false;

   if (nsGkAtoms::tableCaptionFrame == aChildFrame->GetType()) {

     haveCaption = true;

     *aAdjParentFrame = AdjustCaptionParentFrame(aParentFrame);

   }

   return haveCaption;

 }

 void

 nsCSSFrameConstructor::AdjustParentFrame(nsIFrame* &                  aParentFrame,

                                          const FrameConstructionData* aFCData,

                                          nsStyleContext*              aStyleContext)

 {

   NS_PRECONDITION(aStyleContext, "Must have child's style context");

   NS_PRECONDITION(aFCData, "Must have frame construction data");

   bool tablePart = ((aFCData->mBits & FCDATA_IS_TABLE_PART) != 0);

   if (tablePart && aStyleContext->StyleDisplay()->mDisplay ==

       NS_STYLE_DISPLAY_TABLE_CAPTION) {

     aParentFrame = AdjustCaptionParentFrame(aParentFrame);

   }

 }

 // Pull all the captions present in aItems out  into aCaptions

 static void

 PullOutCaptionFrames(nsFrameItems& aItems, nsFrameItems& aCaptions)

 {

   nsIFrame *child = aItems.FirstChild();

   while (child) {

     nsIFrame *nextSibling = child->GetNextSibling();

     if (nsGkAtoms::tableCaptionFrame == child->GetType()) {

       aItems.RemoveFrame(child);

       aCaptions.AddChild(child);

     }

     child = nextSibling;

   }

 }

 // Construct the outer, inner table frames and the children frames for the table.

 // XXX Page break frames for pseudo table frames are not constructed to avoid the risk

 // associated with revising the pseudo frame mechanism. The long term solution

 // of having frames handle page-break-before/after will solve the problem.

 nsIFrame*

 nsCSSFrameConstructor::ConstructTable(nsFrameConstructorState& aState,

                                       FrameConstructionItem&   aItem,

                                       nsIFrame*                aParentFrame,

                                       const nsStyleDisplay*    aDisplay,

                                       nsFrameItems&            aFrameItems)

 {

   NS_PRECONDITION(aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE ||

                   aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_TABLE,

                   "Unexpected call");

   nsIContent* const content = aItem.mContent;

   nsStyleContext* const styleContext = aItem.mStyleContext;

   const uint32_t nameSpaceID = aItem.mNameSpaceID;

   // create the pseudo SC for the outer table as a child of the inner SC

   nsRefPtr<nsStyleContext> outerStyleContext;

   outerStyleContext = mPresShell->StyleSet()->

     ResolveAnonymousBoxStyle(nsCSSAnonBoxes::tableOuter, styleContext);

   // Create the outer table frame which holds the caption and inner table frame

   nsIFrame* newFrame;

   if (kNameSpaceID_MathML == nameSpaceID)

     newFrame = NS_NewMathMLmtableOuterFrame(mPresShell, outerStyleContext);

   else

     newFrame = NS_NewTableOuterFrame(mPresShell, outerStyleContext);

   nsIFrame* geometricParent =

     aState.GetGeometricParent(outerStyleContext->StyleDisplay(),

                               aParentFrame);

   // Init the table outer frame

   InitAndRestoreFrame(aState, content, geometricParent, newFrame);

   // Create the inner table frame

   nsIFrame* innerFrame;

   if (kNameSpaceID_MathML == nameSpaceID)

     innerFrame = NS_NewMathMLmtableFrame(mPresShell, styleContext);

   else

     innerFrame = NS_NewTableFrame(mPresShell, styleContext);

   InitAndRestoreFrame(aState, content, newFrame, innerFrame);

   // Put the newly created frames into the right child list

   SetInitialSingleChild(newFrame, innerFrame);

   aState.AddChild(newFrame, aFrameItems, content, styleContext, aParentFrame);

   if (!mRootElementFrame) {

     // The frame we're constructing will be the root element frame.

     // Set mRootElementFrame before processing children.

     mRootElementFrame = newFrame;

   }

   nsFrameItems childItems;

   // Process children

   nsFrameConstructorSaveState absoluteSaveState;

   const nsStyleDisplay* display = outerStyleContext->StyleDisplay();

   // Mark the table frame as an absolute container if needed

   newFrame->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);

   if (display->IsPositioned(newFrame)) {

     aState.PushAbsoluteContainingBlock(newFrame, newFrame, absoluteSaveState);

   }

   NS_ASSERTION(aItem.mAnonChildren.IsEmpty(),

                "nsIAnonymousContentCreator::CreateAnonymousContent "

                "implementations for table frames are not currently expected "

                "to output a list where the items have their own children");

   if (aItem.mFCData->mBits & FCDATA_USE_CHILD_ITEMS) {

     ConstructFramesFromItemList(aState, aItem.mChildItems,

                                 innerFrame, childItems);

   } else {

     ProcessChildren(aState, content, styleContext, innerFrame,

                     true, childItems, false, aItem.mPendingBinding);

   }

   nsFrameItems captionItems;

   PullOutCaptionFrames(childItems, captionItems);

   // Set the inner table frame's initial primary list

   innerFrame->SetInitialChildList(kPrincipalList, childItems);

   // Set the outer table frame's secondary childlist lists

   if (captionItems.NotEmpty()) {

     newFrame->SetInitialChildList(nsIFrame::kCaptionList, captionItems);

   }

   return newFrame;

 }

 static void

 MakeTablePartAbsoluteContainingBlockIfNeeded(nsFrameConstructorState&     aState,

                                              const nsStyleDisplay*        aDisplay,

                                              nsFrameConstructorSaveState& aAbsSaveState,

                                              nsIFrame*                    aFrame)

 {

   // If we're positioned, then we need to become an absolute containing block

   // for any absolutely positioned children and register for post-reflow fixup.

   //

   // Note that usually if a frame type can be an absolute containing block, we

   // always set NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN, whether it actually is or not.

   // However, in this case flag serves the additional purpose of indicating that

   // the frame was registered with its table frame. This allows us to avoid the

   // overhead of unregistering the frame in most cases.

   if (aDisplay->IsPositioned(aFrame)) {

     aFrame->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);

     aState.PushAbsoluteContainingBlock(aFrame, aFrame, aAbsSaveState);

     nsTableFrame::RegisterPositionedTablePart(aFrame);

   }

 }

 nsIFrame*

 nsCSSFrameConstructor::ConstructTableRowOrRowGroup(nsFrameConstructorState& aState,

                                                    FrameConstructionItem&   aItem,

                                                    nsIFrame*                aParentFrame,

                                                    const nsStyleDisplay*    aDisplay,

                                                    nsFrameItems&            aFrameItems)

 {

   NS_PRECONDITION(aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_ROW ||

                   aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_ROW_GROUP ||

                   aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP ||

                   aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_HEADER_GROUP,

                   "Unexpected call");

   MOZ_ASSERT(aItem.mStyleContext->StyleDisplay() == aDisplay,

              "Display style doesn't match style context");

   nsIContent* const content = aItem.mContent;

   nsStyleContext* const styleContext = aItem.mStyleContext;

   const uint32_t nameSpaceID = aItem.mNameSpaceID;

   nsIFrame* newFrame;

   if (aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_ROW) {

     if (kNameSpaceID_MathML == nameSpaceID)

       newFrame = NS_NewMathMLmtrFrame(mPresShell, styleContext);

     else

       newFrame = NS_NewTableRowFrame(mPresShell, styleContext);

   } else {

     newFrame = NS_NewTableRowGroupFrame(mPresShell, styleContext);

   }

   InitAndRestoreFrame(aState, content, aParentFrame, newFrame);

   nsFrameConstructorSaveState absoluteSaveState;

   MakeTablePartAbsoluteContainingBlockIfNeeded(aState, aDisplay,

                                                absoluteSaveState,

                                                newFrame);

   nsFrameItems childItems;

   NS_ASSERTION(aItem.mAnonChildren.IsEmpty(),

                "nsIAnonymousContentCreator::CreateAnonymousContent "

                "implementations for table frames are not currently expected "

                "to output a list where the items have their own children");

   if (aItem.mFCData->mBits & FCDATA_USE_CHILD_ITEMS) {

     ConstructFramesFromItemList(aState, aItem.mChildItems, newFrame,

                                 childItems);

   } else {

     ProcessChildren(aState, content, styleContext, newFrame,

                     true, childItems, false, aItem.mPendingBinding);

   }

   newFrame->SetInitialChildList(kPrincipalList, childItems);

   aFrameItems.AddChild(newFrame);

   return newFrame;

 }

 nsIFrame*

 nsCSSFrameConstructor::ConstructTableCol(nsFrameConstructorState& aState,

                                          FrameConstructionItem&   aItem,

                                          nsIFrame*                aParentFrame,

                                          const nsStyleDisplay*    aStyleDisplay,

                                          nsFrameItems&            aFrameItems)

 {

   nsIContent* const content = aItem.mContent;

   nsStyleContext* const styleContext = aItem.mStyleContext;

   nsTableColFrame* colFrame = NS_NewTableColFrame(mPresShell, styleContext);

   InitAndRestoreFrame(aState, content, aParentFrame, colFrame);

   NS_ASSERTION(colFrame->StyleContext() == styleContext,

                "Unexpected style context");

   aFrameItems.AddChild(colFrame);

   // construct additional col frames if the col frame has a span > 1

   int32_t span = colFrame->GetSpan();

   for (int32_t spanX = 1; spanX < span; spanX++) {

     nsTableColFrame* newCol = NS_NewTableColFrame(mPresShell, styleContext);

     InitAndRestoreFrame(aState, content, aParentFrame, newCol, false);

     aFrameItems.LastChild()->SetNextContinuation(newCol);

     newCol->SetPrevContinuation(aFrameItems.LastChild());

     aFrameItems.AddChild(newCol);

     newCol->SetColType(eColAnonymousCol);

   }

   return colFrame;

 }

 nsIFrame*

 nsCSSFrameConstructor::ConstructTableCell(nsFrameConstructorState& aState,

                                           FrameConstructionItem&   aItem,

                                           nsIFrame*                aParentFrame,

                                           const nsStyleDisplay*    aDisplay,

                                           nsFrameItems&            aFrameItems)

 {

   NS_PRECONDITION(aDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_CELL,

                   "Unexpected call");

   nsIContent* const content = aItem.mContent;

   nsStyleContext* const styleContext = aItem.mStyleContext;

   const uint32_t nameSpaceID = aItem.mNameSpaceID;

   bool borderCollapse = IsBorderCollapse(aParentFrame);

   nsIFrame* newFrame;

   // <mtable> is border separate in mathml.css and the MathML code doesn't implement

   // border collapse. For those users who style <mtable> with border collapse,

   // give them the default non-MathML table frames that understand border collapse.

   // This won't break us because MathML table frames are all subclasses of the default

   // table code, and so we can freely mix <mtable> with <mtr> or <tr>, <mtd> or <td>.

   // What will happen is just that non-MathML frames won't understand MathML attributes

   // and will therefore miss the special handling that the MathML code does.

   if (kNameSpaceID_MathML == nameSpaceID && !borderCollapse)

     newFrame = NS_NewMathMLmtdFrame(mPresShell, styleContext);

   else

     // Warning: If you change this and add a wrapper frame around table cell

     // frames, make sure Bug 368554 doesn't regress!

     // See IsInAutoWidthTableCellForQuirk() in nsImageFrame.cpp.

     newFrame = NS_NewTableCellFrame(mPresShell, styleContext, borderCollapse);

   // Initialize the table cell frame

   InitAndRestoreFrame(aState, content, aParentFrame, newFrame);

   // Resolve pseudo style and initialize the body cell frame

   nsRefPtr<nsStyleContext> innerPseudoStyle;

   innerPseudoStyle = mPresShell->StyleSet()->

     ResolveAnonymousBoxStyle(nsCSSAnonBoxes::cellContent, styleContext);

   // Create a block frame that will format the cell's content

   bool isBlock;

   nsIFrame* cellInnerFrame;

   if (kNameSpaceID_MathML == nameSpaceID) {

     cellInnerFrame = NS_NewMathMLmtdInnerFrame(mPresShell, innerPseudoStyle);

     isBlock = false;

   } else {

     cellInnerFrame = NS_NewBlockFormattingContext(mPresShell, innerPseudoStyle);

     isBlock = true;

   }

   InitAndRestoreFrame(aState, content, newFrame, cellInnerFrame);

   nsFrameConstructorSaveState absoluteSaveState;

   MakeTablePartAbsoluteContainingBlockIfNeeded(aState, aDisplay,

                                                absoluteSaveState,

                                                newFrame);

   nsFrameItems childItems;

   NS_ASSERTION(aItem.mAnonChildren.IsEmpty(),

                "nsIAnonymousContentCreator::CreateAnonymousContent "

                "implementations for table frames are not currently expected "

                "to output a list where the items have their own children");

   if (aItem.mFCData->mBits & FCDATA_USE_CHILD_ITEMS) {

     // Need to push ourselves as a float containing block.

     // XXXbz it might be nice to work on getting the parent

     // FrameConstructionItem down into ProcessChildren and just making use of

     // the push there, but that's a bit of work.

     nsFrameConstructorSaveState floatSaveState;

     if (!isBlock) { /* MathML case */

       aState.PushFloatContainingBlock(nullptr, floatSaveState);

     } else {

       aState.PushFloatContainingBlock(cellInnerFrame, floatSaveState);

     }

     ConstructFramesFromItemList(aState, aItem.mChildItems, cellInnerFrame,

                                 childItems);

   } else {

     // Process the child content

     ProcessChildren(aState, content, styleContext, cellInnerFrame,

                     true, childItems, isBlock, aItem.mPendingBinding);

   }

   cellInnerFrame->SetInitialChildList(kPrincipalList, childItems);

   SetInitialSingleChild(newFrame, cellInnerFrame);

   aFrameItems.AddChild(newFrame);

   return newFrame;

 }

 static inline bool

 NeedFrameFor(const nsFrameConstructorState& aState,

              nsIFrame*   aParentFrame,

              nsIContent* aChildContent)

 {

   // XXX the GetContent() != aChildContent check is needed due to bug 135040.

   // Remove it once that's fixed.

   NS_PRECONDITION(!aChildContent->GetPrimaryFrame() ||

                   aState.mCreatingExtraFrames ||

                   aChildContent->GetPrimaryFrame()->GetContent() != aChildContent,

                   "Why did we get called?");

   // don't create a whitespace frame if aParentFrame doesn't want it.

   // always create frames for children in generated content. counter(),

   // quotes, and attr() content can easily change dynamically and we don't

   // want to be reconstructing frames. It's not even clear that these

   // should be considered ignorable just because they evaluate to

   // whitespace.

   // We could handle all this in CreateNeededTablePseudos or some other place

   // after we build our frame construction items, but that would involve

   // creating frame construction items for whitespace kids of

   // eExcludesIgnorableWhitespace frames, where we know we'll be dropping them

   // all anyway, and involve an extra walk down the frame construction item

   // list.

   if (!aParentFrame->IsFrameOfType(nsIFrame::eExcludesIgnorableWhitespace) ||

       aParentFrame->IsGeneratedContentFrame() ||

       !aChildContent->IsNodeOfType(nsINode::eTEXT)) {

     return true;

   }

   aChildContent->SetFlags(NS_CREATE_FRAME_IF_NON_WHITESPACE |

                           NS_REFRAME_IF_WHITESPACE);

   return !aChildContent->TextIsOnlyWhitespace();

 }

 /***********************************************

  * END TABLE SECTION

  ***********************************************/

 static bool CheckOverflow(nsPresContext* aPresContext,

                             const nsStyleDisplay* aDisplay)

 {

   if (aDisplay->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE)

     return false;

   if (aDisplay->mOverflowX == NS_STYLE_OVERFLOW_CLIP)

     aPresContext->SetViewportOverflowOverride(NS_STYLE_OVERFLOW_HIDDEN,

                                               NS_STYLE_OVERFLOW_HIDDEN);

   else

     aPresContext->SetViewportOverflowOverride(aDisplay->mOverflowX,

                                               aDisplay->mOverflowY);

   return true;

 }

 /**

  * This checks the root element and the HTML BODY, if any, for an "overflow" property

  * that should be applied to the viewport. If one is found then we return the

  * element that we took the overflow from (which should then be treated as

  * "overflow:visible"), and we store the overflow style in the prescontext.

  * @return if scroll was propagated from some content node, the content node it

  *         was propagated from.

  */

 nsIContent*

 nsCSSFrameConstructor::PropagateScrollToViewport()

 {

   // Set default

   nsPresContext* presContext = mPresShell->GetPresContext();

   presContext->SetViewportOverflowOverride(NS_STYLE_OVERFLOW_AUTO,

                                            NS_STYLE_OVERFLOW_AUTO);

   // We never mess with the viewport scroll state

   // when printing or in print preview

   if (presContext->IsPaginated()) {

     return nullptr;

   }

   Element* docElement = mDocument->GetRootElement();

   // Check the style on the document root element

   nsStyleSet *styleSet = mPresShell->StyleSet();

   nsRefPtr<nsStyleContext> rootStyle;

   rootStyle = styleSet->ResolveStyleFor(docElement, nullptr);

   if (CheckOverflow(presContext, rootStyle->StyleDisplay())) {

     // tell caller we stole the overflow style from the root element

     return docElement;

   }

   // Don't look in the BODY for non-HTML documents or HTML documents

   // with non-HTML roots

   // XXX this should be earlier; we shouldn't even look at the document root

   // for non-HTML documents. Fix this once we support explicit CSS styling

   // of the viewport

   // XXX what about XHTML?

   nsCOMPtr<nsIDOMHTMLDocument> htmlDoc(do_QueryInterface(mDocument));

   if (!htmlDoc || !docElement->IsHTML()) {

     return nullptr;

   }

   nsCOMPtr<nsIDOMHTMLElement> body;

   htmlDoc->GetBody(getter_AddRefs(body));

   nsCOMPtr<nsIContent> bodyElement = do_QueryInterface(body);

   if (!bodyElement ||

       !bodyElement->NodeInfo()->Equals(nsGkAtoms::body)) {

     // The body is not a <body> tag, it's a <frameset>.

     return nullptr;

   }

   nsRefPtr<nsStyleContext> bodyStyle;

   bodyStyle = styleSet->ResolveStyleFor(bodyElement->AsElement(), rootStyle);

   if (CheckOverflow(presContext, bodyStyle->StyleDisplay())) {

     // tell caller we stole the overflow style from the body element

     return bodyElement;

   }

   return nullptr;

 }

 nsIFrame*

 nsCSSFrameConstructor::ConstructDocElementFrame(Element*                 aDocElement,

                                                 nsILayoutHistoryState*   aFrameState)

 {

   NS_PRECONDITION(mFixedContainingBlock,

                   "No viewport?  Someone forgot to call ConstructRootFrame!");

   NS_PRECONDITION(mFixedContainingBlock == GetRootFrame(),

                   "Unexpected mFixedContainingBlock");

   NS_PRECONDITION(!mDocElementContainingBlock,

                   "Shouldn't have a doc element containing block here");

   // Make sure to call PropagateScrollToViewport before

   // SetUpDocElementContainingBlock, since it sets up our scrollbar state

   // properly.

 #ifdef DEBUG

   nsIContent* propagatedScrollFrom =

 #endif

     PropagateScrollToViewport();

   SetUpDocElementContainingBlock(aDocElement);

   NS_ASSERTION(mDocElementContainingBlock, "Should have parent by now");

   nsFrameConstructorState state(mPresShell, mFixedContainingBlock, nullptr,

                                 nullptr, aFrameState);

   // Initialize the ancestor filter with null for now; we'll push

   // aDocElement once we finish resolving style for it.

   state.mTreeMatchContext.InitAncestors(nullptr);

   // XXXbz why, exactly?

   if (!mTempFrameTreeState)

     state.mPresShell->CaptureHistoryState(getter_AddRefs(mTempFrameTreeState));

   // Make sure that we'll handle restyles for this document element in

   // the future.  We need this, because the document element might

   // have stale restyle bits from a previous frame constructor for

   // this document.  Unlike in AddFrameConstructionItems, it's safe to

   // unset all element restyle flags, since we don't have any

   // siblings.

   aDocElement->UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS);

   // --------- CREATE AREA OR BOX FRAME -------

   nsRefPtr<nsStyleContext> styleContext;

   styleContext = mPresShell->StyleSet()->ResolveStyleFor(aDocElement,

                                                          nullptr);

   const nsStyleDisplay* display = styleContext->StyleDisplay();

   // Ensure that our XBL bindings are installed.

   if (display->mBinding) {

     // Get the XBL loader.

     nsresult rv;

     bool resolveStyle;

     nsXBLService* xblService = nsXBLService::GetInstance();

     if (!xblService) {

       return nullptr;

     }

     nsRefPtr<nsXBLBinding> binding;

     rv = xblService->LoadBindings(aDocElement, display->mBinding->GetURI(),

                                   display->mBinding->mOriginPrincipal,

                                   getter_AddRefs(binding), &resolveStyle);

     if (NS_FAILED(rv) && rv != NS_ERROR_XBL_BLOCKED)

       return nullptr; // Binding will load asynchronously.

     if (binding) {

       // For backwards compat, keep firing the root's constructor

       // after all of its kids' constructors.  So tell the binding

       // manager about it right now.

       mDocument->BindingManager()->AddToAttachedQueue(binding);

     }

     if (resolveStyle) {

       styleContext = mPresShell->StyleSet()->ResolveStyleFor(aDocElement,

                                                              nullptr);

       display = styleContext->StyleDisplay();

     }

   }

   // --------- IF SCROLLABLE WRAP IN SCROLLFRAME --------

 #ifdef DEBUG

   NS_ASSERTION(!display->IsScrollableOverflow() ||

                state.mPresContext->IsPaginated() ||

                propagatedScrollFrom == aDocElement,

                "Scrollbars should have been propagated to the viewport");

 #endif

   if (MOZ_UNLIKELY(display->mDisplay == NS_STYLE_DISPLAY_NONE)) {

     SetUndisplayedContent(aDocElement, styleContext);

     return nullptr;

   }

   TreeMatchContext::AutoAncestorPusher ancestorPusher(state.mTreeMatchContext);

   ancestorPusher.PushAncestorAndStyleScope(aDocElement);

   // Make sure to start any background image loads for the root element now.

   styleContext->StartBackgroundImageLoads();

   nsFrameConstructorSaveState absoluteSaveState;

   if (mHasRootAbsPosContainingBlock) {

     // Push the absolute containing block now so we can absolutely position

     // the root element

     mDocElementContainingBlock->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);

     state.PushAbsoluteContainingBlock(mDocElementContainingBlock,

                                       mDocElementContainingBlock,

                                       absoluteSaveState);

   }

   // The rules from CSS 2.1, section 9.2.4, have already been applied

   // by the style system, so we can assume that display->mDisplay is

   // either NONE, BLOCK, or TABLE.

   // contentFrame is the primary frame for the root element. newFrame

   // is the frame that will be the child of the initial containing block.

   // These are usually the same frame but they can be different, in

   // particular if the root frame is positioned, in which case

   // contentFrame is the out-of-flow frame and newFrame is the

   // placeholder.

   nsIFrame* contentFrame;

   nsIFrame* newFrame;

   bool processChildren = false;

   // Check whether we need to build a XUL box or SVG root frame

 #ifdef MOZ_XUL

   if (aDocElement->IsXUL()) {

     contentFrame = NS_NewDocElementBoxFrame(mPresShell, styleContext);

     InitAndRestoreFrame(state, aDocElement, mDocElementContainingBlock,

                         contentFrame);

     newFrame = contentFrame;

     processChildren = true;

   }

   else

 #endif

   if (aDocElement->IsSVG()) {

     if (aDocElement->Tag() != nsGkAtoms::svg) {

       return nullptr;

     }

     // We're going to call the right function ourselves, so no need to give a

     // function to this FrameConstructionData.

     // XXXbz on the other hand, if we converted this whole function to

     // FrameConstructionData/Item, then we'd need the right function

     // here... but would probably be able to get away with less code in this

     // function in general.

     // Use a null PendingBinding, since our binding is not in fact pending.

     static const FrameConstructionData rootSVGData = FCDATA_DECL(0, nullptr);

     already_AddRefed<nsStyleContext> extraRef =

       nsRefPtr<nsStyleContext>(styleContext).forget();

     FrameConstructionItem item(&rootSVGData, aDocElement,

                                aDocElement->Tag(), kNameSpaceID_SVG,

                                nullptr, extraRef, true, nullptr);

     nsFrameItems frameItems;

     contentFrame = ConstructOuterSVG(state, item, mDocElementContainingBlock,

                                      styleContext->StyleDisplay(),

                                      frameItems);

     newFrame = frameItems.FirstChild();

     NS_ASSERTION(frameItems.OnlyChild(), "multiple root element frames");

   } else if (display->mDisplay == NS_STYLE_DISPLAY_FLEX) {

     contentFrame = NS_NewFlexContainerFrame(mPresShell, styleContext);

     InitAndRestoreFrame(state, aDocElement, mDocElementContainingBlock,

                         contentFrame);

     newFrame = contentFrame;

     processChildren = true;

   } else if (display->mDisplay == NS_STYLE_DISPLAY_GRID) {

     contentFrame = NS_NewGridContainerFrame(mPresShell, styleContext);

     InitAndRestoreFrame(state, aDocElement, mDocElementContainingBlock,

                         contentFrame);

     newFrame = contentFrame;

     processChildren = true;

   } else if (display->mDisplay == NS_STYLE_DISPLAY_TABLE) {

     // We're going to call the right function ourselves, so no need to give a

     // function to this FrameConstructionData.

     // XXXbz on the other hand, if we converted this whole function to

     // FrameConstructionData/Item, then we'd need the right function

     // here... but would probably be able to get away with less code in this

     // function in general.

     // Use a null PendingBinding, since our binding is not in fact pending.

     static const FrameConstructionData rootTableData = FCDATA_DECL(0, nullptr);

     already_AddRefed<nsStyleContext> extraRef =

       nsRefPtr<nsStyleContext>(styleContext).forget();

     FrameConstructionItem item(&rootTableData, aDocElement,

                                aDocElement->Tag(), kNameSpaceID_None,

                                nullptr, extraRef, true, nullptr);

     nsFrameItems frameItems;

     // if the document is a table then just populate it.

     contentFrame = ConstructTable(state, item, mDocElementContainingBlock,

                                   styleContext->StyleDisplay(),

                                   frameItems);

     newFrame = frameItems.FirstChild();

     NS_ASSERTION(frameItems.OnlyChild(), "multiple root element frames");

   } else {

     MOZ_ASSERT(display->mDisplay == NS_STYLE_DISPLAY_BLOCK,

                "Unhandled display type for root element");

     contentFrame = NS_NewBlockFormattingContext(mPresShell, styleContext);

     nsFrameItems frameItems;

     // Use a null PendingBinding, since our binding is not in fact pending.

     ConstructBlock(state, display, aDocElement,

                    state.GetGeometricParent(display,

                                             mDocElementContainingBlock),

                    mDocElementContainingBlock, styleContext,

                    &contentFrame, frameItems,

                    display->IsPositioned(contentFrame) ? contentFrame : nullptr,

                    nullptr);

     newFrame = frameItems.FirstChild();

     NS_ASSERTION(frameItems.OnlyChild(), "multiple root element frames");

   }

   MOZ_ASSERT(newFrame);

   MOZ_ASSERT(contentFrame);

   NS_ASSERTION(processChildren ? !mRootElementFrame :

                  mRootElementFrame == contentFrame,

                "unexpected mRootElementFrame");

   mRootElementFrame = contentFrame;

   // Figure out which frame has the main style for the document element,

   // assigning it to mRootElementStyleFrame.

   // Backgrounds should be propagated from that frame to the viewport.

   mRootElementStyleFrame = contentFrame->GetParentStyleContextFrame();

   bool isChild = mRootElementStyleFrame &&

                  mRootElementStyleFrame->GetParent() == contentFrame;

   if (!isChild) {

     mRootElementStyleFrame = mRootElementFrame;

   }

   if (processChildren) {

     // Still need to process the child content

     nsFrameItems childItems;

     NS_ASSERTION(!nsLayoutUtils::GetAsBlock(contentFrame) &&

                  !contentFrame->IsFrameOfType(nsIFrame::eSVG),

                  "Only XUL frames should reach here");

     // Use a null PendingBinding, since our binding is not in fact pending.

     ProcessChildren(state, aDocElement, styleContext, contentFrame, true,

                     childItems, false, nullptr);

     // Set the initial child lists

     contentFrame->SetInitialChildList(kPrincipalList, childItems);

   }

   // set the primary frame

   aDocElement->SetPrimaryFrame(contentFrame);

   SetInitialSingleChild(mDocElementContainingBlock, newFrame);

   return newFrame;

 }

 nsIFrame*

 nsCSSFrameConstructor::ConstructRootFrame()

 {

   AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);

   nsStyleSet *styleSet = mPresShell->StyleSet();

   // Set up our style rule observer.

   // XXXbz wouldn't this make more sense as part of presshell init?

   {

     styleSet->SetBindingManager(mDocument->BindingManager());

   }

   // --------- BUILD VIEWPORT -----------

   nsIFrame*                 viewportFrame = nullptr;

   nsRefPtr<nsStyleContext> viewportPseudoStyle;

   viewportPseudoStyle =

     styleSet->ResolveAnonymousBoxStyle(nsCSSAnonBoxes::viewport, nullptr);

   viewportFrame = NS_NewViewportFrame(mPresShell, viewportPseudoStyle);

   // XXXbz do we _have_ to pass a null content pointer to that frame?

   // Would it really kill us to pass in the root element or something?

   // What would that break?

   viewportFrame->Init(nullptr, nullptr, nullptr);

   // Bind the viewport frame to the root view

   nsView* rootView = mPresShell->GetViewManager()->GetRootView();

   viewportFrame->SetView(rootView);

   nsContainerFrame::SyncFrameViewProperties(mPresShell->GetPresContext(), viewportFrame,

                                             viewportPseudoStyle, rootView);

   nsContainerFrame::SyncWindowProperties(mPresShell->GetPresContext(), viewportFrame,

                                          rootView);

   // The viewport is the containing block for 'fixed' elements

   mFixedContainingBlock = viewportFrame;

   // Make it an absolute container for fixed-pos elements

   mFixedContainingBlock->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);

   mFixedContainingBlock->MarkAsAbsoluteContainingBlock();

   return viewportFrame;

 }

 void

 nsCSSFrameConstructor::SetUpDocElementContainingBlock(nsIContent* aDocElement)

 {

   NS_PRECONDITION(aDocElement, "No element?");

   NS_PRECONDITION(!aDocElement->GetParent(), "Not root content?");

   NS_PRECONDITION(aDocElement->GetCurrentDoc(), "Not in a document?");

   NS_PRECONDITION(aDocElement->GetCurrentDoc()->GetRootElement() ==

                   aDocElement, "Not the root of the document?");

   /*

     how the root frame hierarchy should look

   Galley presentation, non-XUL, with scrolling:

       ViewportFrame [fixed-cb]

         nsHTMLScrollFrame

           nsCanvasFrame [abs-cb]

             root element frame (nsBlockFrame, nsSVGOuterSVGFrame,

                                 nsTableOuterFrame, nsPlaceholderFrame)

   Galley presentation, XUL

       ViewportFrame [fixed-cb]

         nsRootBoxFrame

           root element frame (nsDocElementBoxFrame)

   Print presentation, non-XUL

       ViewportFrame

         nsSimplePageSequenceFrame

           nsPageFrame [fixed-cb]

             nsPageContentFrame

               nsCanvasFrame [abs-cb]

                 root element frame (nsBlockFrame, nsSVGOuterSVGFrame,

                                     nsTableOuterFrame, nsPlaceholderFrame)

   Print-preview presentation, non-XUL

       ViewportFrame

         nsHTMLScrollFrame

           nsSimplePageSequenceFrame

             nsPageFrame [fixed-cb]

               nsPageContentFrame

                 nsCanvasFrame [abs-cb]

                   root element frame (nsBlockFrame, nsSVGOuterSVGFrame,

                                       nsTableOuterFrame, nsPlaceholderFrame)

   Print/print preview of XUL is not supported.

   [fixed-cb]: the default containing block for fixed-pos content

   [abs-cb]: the default containing block for abs-pos content

   Meaning of nsCSSFrameConstructor fields:

     mRootElementFrame is "root element frame".  This is the primary frame for

       the root element.

     mDocElementContainingBlock is the parent of mRootElementFrame

       (i.e. nsCanvasFrame or nsRootBoxFrame)

     mFixedContainingBlock is the [fixed-cb]

     mGfxScrollFrame is the nsHTMLScrollFrame mentioned above, or null if there isn't one

     mPageSequenceFrame is the nsSimplePageSequenceFrame, or null if there isn't one