diff -r 000000000000 -r 6474c204b198 layout/base/nsCSSFrameConstructor.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/layout/base/nsCSSFrameConstructor.cpp Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,11393 @@ +/* -*- 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 + (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 + (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 +{ +#ifdef NS_BUILD_REFCNT_LOGGING + PendingBinding() { + MOZ_COUNT_CTOR(PendingBinding); + } + ~PendingBinding() { + MOZ_COUNT_DTOR(PendingBinding); + } +#endif + + nsRefPtr 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 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 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 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 = 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 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 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 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 mNode; + nsGenConList* mList; + void (nsCSSFrameConstructor::*mDirtyAll)(); + + nsGenConInitializer(nsGenConNode* aNode, nsGenConList* aList, + void (nsCSSFrameConstructor::*aDirtyAll)()) + : mNode(aNode), mList(aList), mDirtyAll(aDirtyAll) {} +}; + +already_AddRefed +nsCSSFrameConstructor::CreateGenConTextNode(nsFrameConstructorState& aState, + const nsString& aString, + nsCOMPtr* aText, + nsGenConInitializer* aInitializer) +{ + nsRefPtr content = new nsTextNode(mDocument->NodeInfoManager()); + content->SetText(aString, false); + if (aText) { + *aText = content; + } + if (aInitializer) { + content->SetProperty(nsGkAtoms::genConInitializerProperty, aInitializer, + nsINode::DeleteProperty); + aState.mGeneratedTextNodesWithInitializer.AppendObject(content); + } + return content.forget(); +} + +already_AddRefed +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 nodeInfo; + nodeInfo = mDocument->NodeInfoManager()-> + GetNodeInfo(nsGkAtoms::mozgeneratedcontentimage, nullptr, + kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); + + nsCOMPtr 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 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 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 + // , 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 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 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 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 nodeInfo; + nsIAtom* elemName = aPseudoElement == nsCSSPseudoElements::ePseudo_before ? + nsGkAtoms::mozgeneratedcontentbefore : nsGkAtoms::mozgeneratedcontentafter; + nodeInfo = mDocument->NodeInfoManager()->GetNodeInfo(elemName, nullptr, + kNameSpaceID_None, + nsIDOMNode::ELEMENT_NODE); + nsCOMPtr 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 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 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; + // is border separate in mathml.css and the MathML code doesn't implement + // border collapse. For those users who style 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 with or , or . + // 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 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 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 htmlDoc(do_QueryInterface(mDocument)); + if (!htmlDoc || !docElement->IsHTML()) { + return nullptr; + } + + nsCOMPtr body; + htmlDoc->GetBody(getter_AddRefs(body)); + nsCOMPtr bodyElement = do_QueryInterface(body); + + if (!bodyElement || + !bodyElement->NodeInfo()->Equals(nsGkAtoms::body)) { + // The body is not a tag, it's a . + return nullptr; + } + + nsRefPtr 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 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 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 extraRef = + nsRefPtr(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 extraRef = + nsRefPtr(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 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 + */ + + // --------- CREATE ROOT FRAME ------- + + + // Create the root frame. The document element's frame is a child of the + // root frame. + // + // The root frame serves two purposes: + // - reserves space for any margins needed for the document element's frame + // - renders the document element's background. This ensures the background covers + // the entire canvas as specified by the CSS2 spec + + nsPresContext* presContext = mPresShell->GetPresContext(); + bool isPaginated = presContext->IsRootPaginatedDocument(); + nsIFrame* viewportFrame = mFixedContainingBlock; + nsStyleContext* viewportPseudoStyle = viewportFrame->StyleContext(); + + nsIFrame* rootFrame = nullptr; + nsIAtom* rootPseudo; + + if (!isPaginated) { +#ifdef MOZ_XUL + if (aDocElement->IsXUL()) + { + // pass a temporary stylecontext, the correct one will be set later + rootFrame = NS_NewRootBoxFrame(mPresShell, viewportPseudoStyle); + } else +#endif + { + // pass a temporary stylecontext, the correct one will be set later + rootFrame = NS_NewCanvasFrame(mPresShell, viewportPseudoStyle); + mHasRootAbsPosContainingBlock = true; + } + + rootPseudo = nsCSSAnonBoxes::canvas; + mDocElementContainingBlock = rootFrame; + } else { + // Create a page sequence frame + rootFrame = NS_NewSimplePageSequenceFrame(mPresShell, viewportPseudoStyle); + mPageSequenceFrame = rootFrame; + rootPseudo = nsCSSAnonBoxes::pageSequence; + } + + + // --------- IF SCROLLABLE WRAP IN SCROLLFRAME -------- + + // If the device supports scrolling (e.g., in galley mode on the screen and + // for print-preview, but not when printing), then create a scroll frame that + // will act as the scrolling mechanism for the viewport. + // XXX Do we even need a viewport when printing to a printer? + + bool isHTML = aDocElement->IsHTML(); + bool isXUL = false; + + if (!isHTML) { + isXUL = aDocElement->IsXUL(); + } + + // Never create scrollbars for XUL documents + bool isScrollable = isPaginated ? presContext->HasPaginatedScrolling() : !isXUL; + + // We no longer need to do overflow propagation here. It's taken care of + // when we construct frames for the element whose overflow might be + // propagated + NS_ASSERTION(!isScrollable || !isXUL, + "XUL documents should never be scrollable - see above"); + + nsIFrame* newFrame = rootFrame; + nsRefPtr rootPseudoStyle; + // we must create a state because if the scrollbars are GFX it needs the + // state to build the scrollbar frames. + nsFrameConstructorState state(mPresShell, nullptr, nullptr, nullptr); + + // Start off with the viewport as parent; we'll adjust it as needed. + nsIFrame* parentFrame = viewportFrame; + + nsStyleSet* styleSet = mPresShell->StyleSet(); + // If paginated, make sure we don't put scrollbars in + if (!isScrollable) { + rootPseudoStyle = styleSet->ResolveAnonymousBoxStyle(rootPseudo, + viewportPseudoStyle); + } else { + if (rootPseudo == nsCSSAnonBoxes::canvas) { + rootPseudo = nsCSSAnonBoxes::scrolledCanvas; + } else { + NS_ASSERTION(rootPseudo == nsCSSAnonBoxes::pageSequence, + "Unknown root pseudo"); + rootPseudo = nsCSSAnonBoxes::scrolledPageSequence; + } + + // Build the frame. We give it the content we are wrapping which is the + // document element, the root frame, the parent view port frame, and we + // should get back the new frame and the scrollable view if one was + // created. + + // resolve a context for the scrollframe + nsRefPtr styleContext; + styleContext = styleSet->ResolveAnonymousBoxStyle(nsCSSAnonBoxes::viewportScroll, + viewportPseudoStyle); + + // Note that the viewport scrollframe is always built with + // overflow:auto style. This forces the scroll frame to create + // anonymous content for both scrollbars. This is necessary even + // if the HTML or BODY elements are overriding the viewport + // scroll style to 'hidden' --- dynamic style changes might put + // scrollbars back on the viewport and we don't want to have to + // reframe the viewport to create the scrollbar content. + newFrame = nullptr; + rootPseudoStyle = BeginBuildingScrollFrame( state, + aDocElement, + styleContext, + viewportFrame, + rootPseudo, + true, + newFrame); + parentFrame = newFrame; + mGfxScrollFrame = newFrame; + } + + rootFrame->SetStyleContextWithoutNotification(rootPseudoStyle); + rootFrame->Init(aDocElement, parentFrame, nullptr); + + if (isScrollable) { + FinishBuildingScrollFrame(parentFrame, rootFrame); + } + + if (isPaginated) { // paginated + // Create the first page + // Set the initial child lists + nsIFrame* canvasFrame; + nsIFrame* pageFrame = + ConstructPageFrame(mPresShell, presContext, rootFrame, nullptr, + canvasFrame); + SetInitialSingleChild(rootFrame, pageFrame); + + // The eventual parent of the document element frame. + // XXX should this be set for every new page (in ConstructPageFrame)? + mDocElementContainingBlock = canvasFrame; + mHasRootAbsPosContainingBlock = true; + } + + if (viewportFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) { + SetInitialSingleChild(viewportFrame, newFrame); + } else { + nsFrameList newFrameList(newFrame, newFrame); + viewportFrame->AppendFrames(kPrincipalList, newFrameList); + } +} + +nsIFrame* +nsCSSFrameConstructor::ConstructPageFrame(nsIPresShell* aPresShell, + nsPresContext* aPresContext, + nsIFrame* aParentFrame, + nsIFrame* aPrevPageFrame, + nsIFrame*& aCanvasFrame) +{ + nsStyleContext* parentStyleContext = aParentFrame->StyleContext(); + nsStyleSet *styleSet = aPresShell->StyleSet(); + + nsRefPtr pagePseudoStyle; + pagePseudoStyle = styleSet->ResolveAnonymousBoxStyle(nsCSSAnonBoxes::page, + parentStyleContext); + + nsIFrame* pageFrame = NS_NewPageFrame(aPresShell, pagePseudoStyle); + + // Initialize the page frame and force it to have a view. This makes printing of + // the pages easier and faster. + pageFrame->Init(nullptr, aParentFrame, aPrevPageFrame); + + nsRefPtr pageContentPseudoStyle; + pageContentPseudoStyle = + styleSet->ResolveAnonymousBoxStyle(nsCSSAnonBoxes::pageContent, + pagePseudoStyle); + + nsIFrame* pageContentFrame = NS_NewPageContentFrame(aPresShell, pageContentPseudoStyle); + + // Initialize the page content frame and force it to have a view. Also make it the + // containing block for fixed elements which are repeated on every page. + nsIFrame* prevPageContentFrame = nullptr; + if (aPrevPageFrame) { + prevPageContentFrame = aPrevPageFrame->GetFirstPrincipalChild(); + NS_ASSERTION(prevPageContentFrame, "missing page content frame"); + } + pageContentFrame->Init(nullptr, pageFrame, prevPageContentFrame); + SetInitialSingleChild(pageFrame, pageContentFrame); + mFixedContainingBlock = pageContentFrame; + // Make it an absolute container for fixed-pos elements + mFixedContainingBlock->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN); + mFixedContainingBlock->MarkAsAbsoluteContainingBlock(); + + nsRefPtr canvasPseudoStyle; + canvasPseudoStyle = styleSet->ResolveAnonymousBoxStyle(nsCSSAnonBoxes::canvas, + pageContentPseudoStyle); + + aCanvasFrame = NS_NewCanvasFrame(aPresShell, canvasPseudoStyle); + + nsIFrame* prevCanvasFrame = nullptr; + if (prevPageContentFrame) { + prevCanvasFrame = prevPageContentFrame->GetFirstPrincipalChild(); + NS_ASSERTION(prevCanvasFrame, "missing canvas frame"); + } + aCanvasFrame->Init(nullptr, pageContentFrame, prevCanvasFrame); + SetInitialSingleChild(pageContentFrame, aCanvasFrame); + return pageFrame; +} + +/* static */ +nsIFrame* +nsCSSFrameConstructor::CreatePlaceholderFrameFor(nsIPresShell* aPresShell, + nsIContent* aContent, + nsIFrame* aFrame, + nsStyleContext* aStyleContext, + nsIFrame* aParentFrame, + nsIFrame* aPrevInFlow, + nsFrameState aTypeBit) +{ + nsRefPtr placeholderStyle = aPresShell->StyleSet()-> + ResolveStyleForNonElement(aStyleContext->GetParent()); + + // The placeholder frame gets a pseudo style context + nsPlaceholderFrame* placeholderFrame = + (nsPlaceholderFrame*)NS_NewPlaceholderFrame(aPresShell, placeholderStyle, + aTypeBit); + + placeholderFrame->Init(aContent, aParentFrame, aPrevInFlow); + + // The placeholder frame has a pointer back to the out-of-flow frame + placeholderFrame->SetOutOfFlowFrame(aFrame); + + aFrame->AddStateBits(NS_FRAME_OUT_OF_FLOW); + + // Add mapping from absolutely positioned frame to its placeholder frame + aPresShell->FrameManager()->RegisterPlaceholderFrame(placeholderFrame); + + return placeholderFrame; +} + +// Clears any lazy bits set in the range [aStartContent, aEndContent). If +// aEndContent is null, that means to clear bits in all siblings starting with +// aStartContent. aStartContent must not be null unless aEndContent is also +// null. We do this so that when new children are inserted under elements whose +// frame is a leaf the new children don't cause us to try to construct frames +// for the existing children again. +static inline void +ClearLazyBits(nsIContent* aStartContent, nsIContent* aEndContent) +{ + NS_PRECONDITION(aStartContent || !aEndContent, + "Must have start child if we have an end child"); + for (nsIContent* cur = aStartContent; cur != aEndContent; + cur = cur->GetNextSibling()) { + cur->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME); + } +} + +nsIFrame* +nsCSSFrameConstructor::ConstructSelectFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems) +{ + nsIContent* const content = aItem.mContent; + nsStyleContext* const styleContext = aItem.mStyleContext; + + // Construct a frame-based listbox or combobox + dom::HTMLSelectElement* sel = dom::HTMLSelectElement::FromContent(content); + MOZ_ASSERT(sel); + if (sel->IsCombobox()) { + // Construct a frame-based combo box. + // The frame-based combo box is built out of three parts. A display area, a button and + // a dropdown list. The display area and button are created through anonymous content. + // The drop-down list's frame is created explicitly. The combobox frame shares its content + // with the drop-down list. + nsFrameState flags = NS_BLOCK_FLOAT_MGR; + nsIFrame* comboboxFrame = NS_NewComboboxControlFrame(mPresShell, styleContext, flags); + + // Save the history state so we don't restore during construction + // since the complete tree is required before we restore. + nsILayoutHistoryState *historyState = aState.mFrameState; + aState.mFrameState = nullptr; + // Initialize the combobox frame + InitAndRestoreFrame(aState, content, + aState.GetGeometricParent(aStyleDisplay, aParentFrame), + comboboxFrame); + + aState.AddChild(comboboxFrame, aFrameItems, content, styleContext, + aParentFrame); + + nsIComboboxControlFrame* comboBox = do_QueryFrame(comboboxFrame); + NS_ASSERTION(comboBox, "NS_NewComboboxControlFrame returned frame that " + "doesn't implement nsIComboboxControlFrame"); + + // Resolve pseudo element style for the dropdown list + nsRefPtr listStyle; + listStyle = mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(nsCSSAnonBoxes::dropDownList, styleContext); + + // Create a listbox + nsIFrame* listFrame = NS_NewListControlFrame(mPresShell, listStyle); + + // Notify the listbox that it is being used as a dropdown list. + nsIListControlFrame * listControlFrame = do_QueryFrame(listFrame); + if (listControlFrame) { + listControlFrame->SetComboboxFrame(comboboxFrame); + } + // Notify combobox that it should use the listbox as it's popup + comboBox->SetDropDown(listFrame); + + NS_ASSERTION(!listFrame->IsPositioned(), + "Ended up with positioned dropdown list somehow."); + NS_ASSERTION(!listFrame->IsFloating(), + "Ended up with floating dropdown list somehow."); + + // Initialize the scroll frame positioned. Note that it is NOT + // initialized as absolutely positioned. + nsIFrame* scrolledFrame = NS_NewSelectsAreaFrame(mPresShell, styleContext, flags); + + InitializeSelectFrame(aState, listFrame, scrolledFrame, content, + comboboxFrame, listStyle, true, + aItem.mPendingBinding, aFrameItems); + + NS_ASSERTION(listFrame->GetView(), "ListFrame's view is nullptr"); + + // Create display and button frames from the combobox's anonymous content. + // The anonymous content is appended to existing anonymous content for this + // element (the scrollbars). + + nsFrameItems childItems; + CreateAnonymousFrames(aState, content, comboboxFrame, + aItem.mPendingBinding, childItems); + + comboboxFrame->SetInitialChildList(kPrincipalList, childItems); + + // Initialize the additional popup child list which contains the + // dropdown list frame. + nsFrameItems popupItems; + popupItems.AddChild(listFrame); + comboboxFrame->SetInitialChildList(nsIFrame::kSelectPopupList, + popupItems); + + aState.mFrameState = historyState; + if (aState.mFrameState) { + // Restore frame state for the entire subtree of |comboboxFrame|. + RestoreFrameState(comboboxFrame, aState.mFrameState); + } + return comboboxFrame; + } + + // Listbox, not combobox + nsIFrame* listFrame = NS_NewListControlFrame(mPresShell, styleContext); + + nsIFrame* scrolledFrame = NS_NewSelectsAreaFrame( + mPresShell, styleContext, NS_BLOCK_FLOAT_MGR); + + // ******* this code stolen from Initialze ScrollFrame ******** + // please adjust this code to use BuildScrollFrame. + + InitializeSelectFrame(aState, listFrame, scrolledFrame, content, + aParentFrame, styleContext, false, + aItem.mPendingBinding, aFrameItems); + + return listFrame; +} + +/** + * Used to be InitializeScrollFrame but now it's only used for the select tag + * But the select tag should really be fixed to use GFX scrollbars that can + * be create with BuildScrollFrame. + */ +nsresult +nsCSSFrameConstructor::InitializeSelectFrame(nsFrameConstructorState& aState, + nsIFrame* scrollFrame, + nsIFrame* scrolledFrame, + nsIContent* aContent, + nsIFrame* aParentFrame, + nsStyleContext* aStyleContext, + bool aBuildCombobox, + PendingBinding* aPendingBinding, + nsFrameItems& aFrameItems) +{ + const nsStyleDisplay* display = aStyleContext->StyleDisplay(); + + // Initialize it + nsIFrame* geometricParent = aState.GetGeometricParent(display, aParentFrame); + + // We don't call InitAndRestoreFrame for scrollFrame because we can only + // restore the frame state after its parts have been created (in particular, + // the scrollable view). So we have to split Init and Restore. + + // Initialize the frame + scrollFrame->Init(aContent, geometricParent, nullptr); + + if (!aBuildCombobox) { + aState.AddChild(scrollFrame, aFrameItems, aContent, + aStyleContext, aParentFrame); + } + + if (aBuildCombobox) { + nsContainerFrame::CreateViewForFrame(scrollFrame, true); + } + + BuildScrollFrame(aState, aContent, aStyleContext, scrolledFrame, + geometricParent, scrollFrame); + + if (aState.mFrameState) { + // Restore frame state for the scroll frame + RestoreFrameStateFor(scrollFrame, aState.mFrameState); + } + + // Process children + nsFrameItems childItems; + + ProcessChildren(aState, aContent, aStyleContext, scrolledFrame, false, + childItems, false, aPendingBinding); + + // Set the scrolled frame's initial child lists + scrolledFrame->SetInitialChildList(kPrincipalList, childItems); + return NS_OK; +} + +nsIFrame* +nsCSSFrameConstructor::ConstructFieldSetFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems) +{ + nsIContent* const content = aItem.mContent; + nsStyleContext* const styleContext = aItem.mStyleContext; + + nsIFrame* fieldsetFrame = NS_NewFieldSetFrame(mPresShell, styleContext); + + // Initialize it + InitAndRestoreFrame(aState, content, + aState.GetGeometricParent(aStyleDisplay, aParentFrame), + fieldsetFrame); + + // Resolve style and initialize the frame + nsRefPtr fieldsetContentStyle; + fieldsetContentStyle = mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(nsCSSAnonBoxes::fieldsetContent, styleContext); + + const nsStyleDisplay* fieldsetContentDisplay = fieldsetContentStyle->StyleDisplay(); + bool isScrollable = fieldsetContentDisplay->IsScrollableOverflow(); + nsIFrame* scrollFrame = nullptr; + if (isScrollable) { + fieldsetContentStyle = + BeginBuildingScrollFrame(aState, content, fieldsetContentStyle, + fieldsetFrame, nsCSSAnonBoxes::scrolledContent, + false, scrollFrame); + } + + nsIFrame* blockFrame = NS_NewBlockFrame(mPresShell, fieldsetContentStyle, + NS_BLOCK_FLOAT_MGR | + NS_BLOCK_MARGIN_ROOT); + InitAndRestoreFrame(aState, content, + scrollFrame ? scrollFrame : fieldsetFrame, blockFrame); + + aState.AddChild(fieldsetFrame, aFrameItems, content, styleContext, aParentFrame); + + // Process children + nsFrameConstructorSaveState absoluteSaveState; + nsFrameItems childItems; + + blockFrame->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN); + if (fieldsetFrame->IsPositioned()) { + aState.PushAbsoluteContainingBlock(blockFrame, fieldsetFrame, absoluteSaveState); + } + + ProcessChildren(aState, content, styleContext, blockFrame, true, + childItems, true, aItem.mPendingBinding); + + nsFrameItems fieldsetKids; + fieldsetKids.AddChild(scrollFrame ? scrollFrame : blockFrame); + + for (nsFrameList::Enumerator e(childItems); !e.AtEnd(); e.Next()) { + nsIFrame* child = e.get(); + if (child->GetContentInsertionFrame()->GetType() == nsGkAtoms::legendFrame) { + // We want the legend to be the first frame in the fieldset child list. + // That way the EventStateManager will do the right thing when tabbing + // from a selection point within the legend (bug 236071), which is + // used for implementing legend access keys (bug 81481). + // GetAdjustedParentFrame() below depends on this frame order. + childItems.RemoveFrame(child); + // Make sure to reparent the legend so it has the fieldset as the parent. + fieldsetKids.InsertFrame(fieldsetFrame, nullptr, child); + if (scrollFrame) { + StickyScrollContainer::NotifyReparentedFrameAcrossScrollFrameBoundary( + child, blockFrame); + } + break; + } + } + + if (isScrollable) { + FinishBuildingScrollFrame(scrollFrame, blockFrame); + } + + // Set the inner frame's initial child lists + blockFrame->SetInitialChildList(kPrincipalList, childItems); + + // Set the outer frame's initial child list + fieldsetFrame->SetInitialChildList(kPrincipalList, fieldsetKids); + + fieldsetFrame->AddStateBits(NS_FRAME_MAY_HAVE_GENERATED_CONTENT); + + // Our new frame returned is the outer frame, which is the fieldset frame. + return fieldsetFrame; +} + +static nsIFrame* +FindAncestorWithGeneratedContentPseudo(nsIFrame* aFrame) +{ + for (nsIFrame* f = aFrame->GetParent(); f; f = f->GetParent()) { + NS_ASSERTION(f->IsGeneratedContentFrame(), + "should not have exited generated content"); + nsIAtom* pseudo = f->StyleContext()->GetPseudo(); + if (pseudo == nsCSSPseudoElements::before || + pseudo == nsCSSPseudoElements::after) + return f; + } + return nullptr; +} + +#define SIMPLE_FCDATA(_func) FCDATA_DECL(0, _func) +#define FULL_CTOR_FCDATA(_flags, _func) \ + { _flags | FCDATA_FUNC_IS_FULL_CTOR, { nullptr }, _func, nullptr } + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindTextData(nsIFrame* aParentFrame) +{ + if (aParentFrame && IsFrameForSVG(aParentFrame)) { + nsIFrame *ancestorFrame = + nsSVGUtils::GetFirstNonAAncestorFrame(aParentFrame); + if (ancestorFrame) { + static const FrameConstructionData sSVGTextData = + FCDATA_DECL(FCDATA_IS_LINE_PARTICIPANT | FCDATA_IS_SVG_TEXT, + NS_NewTextFrame); + if (ancestorFrame->IsSVGText()) { + return &sSVGTextData; + } + } + return nullptr; + } + + static const FrameConstructionData sTextData = + FCDATA_DECL(FCDATA_IS_LINE_PARTICIPANT, NS_NewTextFrame); + return &sTextData; +} + +void +nsCSSFrameConstructor::ConstructTextFrame(const FrameConstructionData* aData, + nsFrameConstructorState& aState, + nsIContent* aContent, + nsIFrame* aParentFrame, + nsStyleContext* aStyleContext, + nsFrameItems& aFrameItems) +{ + NS_PRECONDITION(aData, "Must have frame construction data"); + + nsIFrame* newFrame = (*aData->mFunc.mCreationFunc)(mPresShell, aStyleContext); + + InitAndRestoreFrame(aState, aContent, aParentFrame, newFrame); + + // We never need to create a view for a text frame. + + if (newFrame->IsGeneratedContentFrame()) { + nsAutoPtr initializer; + initializer = + static_cast( + aContent->UnsetProperty(nsGkAtoms::genConInitializerProperty)); + if (initializer) { + if (initializer->mNode->InitTextFrame(initializer->mList, + FindAncestorWithGeneratedContentPseudo(newFrame), newFrame)) { + (this->*(initializer->mDirtyAll))(); + } + initializer->mNode.forget(); + } + } + + // Add the newly constructed frame to the flow + aFrameItems.AddChild(newFrame); + + if (!aState.mCreatingExtraFrames) + aContent->SetPrimaryFrame(newFrame); +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindDataByInt(int32_t aInt, + Element* aElement, + nsStyleContext* aStyleContext, + const FrameConstructionDataByInt* aDataPtr, + uint32_t aDataLength) +{ + for (const FrameConstructionDataByInt *curData = aDataPtr, + *endData = aDataPtr + aDataLength; + curData != endData; + ++curData) { + if (curData->mInt == aInt) { + const FrameConstructionData* data = &curData->mData; + if (data->mBits & FCDATA_FUNC_IS_DATA_GETTER) { + return data->mFunc.mDataGetter(aElement, aStyleContext); + } + + return data; + } + } + + return nullptr; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindDataByTag(nsIAtom* aTag, + Element* aElement, + nsStyleContext* aStyleContext, + const FrameConstructionDataByTag* aDataPtr, + uint32_t aDataLength) +{ + for (const FrameConstructionDataByTag *curData = aDataPtr, + *endData = aDataPtr + aDataLength; + curData != endData; + ++curData) { + if (*curData->mTag == aTag) { + const FrameConstructionData* data = &curData->mData; + if (data->mBits & FCDATA_FUNC_IS_DATA_GETTER) { + return data->mFunc.mDataGetter(aElement, aStyleContext); + } + + return data; + } + } + + return nullptr; +} + +#define SUPPRESS_FCDATA() FCDATA_DECL(FCDATA_SUPPRESS_FRAME, nullptr) +#define SIMPLE_INT_CREATE(_int, _func) { _int, SIMPLE_FCDATA(_func) } +#define SIMPLE_INT_CHAIN(_int, _func) \ + { _int, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) } +#define COMPLEX_INT_CREATE(_int, _func) \ + { _int, FULL_CTOR_FCDATA(0, _func) } + +#define SIMPLE_TAG_CREATE(_tag, _func) \ + { &nsGkAtoms::_tag, SIMPLE_FCDATA(_func) } +#define SIMPLE_TAG_CHAIN(_tag, _func) \ + { &nsGkAtoms::_tag, FCDATA_DECL(FCDATA_FUNC_IS_DATA_GETTER, _func) } +#define COMPLEX_TAG_CREATE(_tag, _func) \ + { &nsGkAtoms::_tag, FULL_CTOR_FCDATA(0, _func) } + +static bool +IsFrameForFieldSet(nsIFrame* aFrame, nsIAtom* aFrameType) +{ + nsIAtom* pseudo = aFrame->StyleContext()->GetPseudo(); + if (pseudo == nsCSSAnonBoxes::fieldsetContent || + pseudo == nsCSSAnonBoxes::scrolledContent) { + return IsFrameForFieldSet(aFrame->GetParent(), aFrame->GetParent()->GetType()); + } + return aFrameType == nsGkAtoms::fieldSetFrame; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindHTMLData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsIFrame* aParentFrame, + nsStyleContext* aStyleContext) +{ + // Ignore the tag if it's not HTML content and if it doesn't extend (via XBL) + // a valid HTML namespace. This check must match the one in + // ShouldHaveFirstLineStyle. + if (aNameSpaceID != kNameSpaceID_XHTML) { + return nullptr; + } + + NS_ASSERTION(!aParentFrame || + aParentFrame->StyleContext()->GetPseudo() != + nsCSSAnonBoxes::fieldsetContent || + aParentFrame->GetParent()->GetType() == nsGkAtoms::fieldSetFrame, + "Unexpected parent for fieldset content anon box"); + if (aTag == nsGkAtoms::legend && + (!aParentFrame || + !IsFrameForFieldSet(aParentFrame, aParentFrame->GetType()) || + !aElement->GetParent() || + !aElement->GetParent()->IsHTML(nsGkAtoms::fieldset) || + aStyleContext->StyleDisplay()->IsFloatingStyle() || + aStyleContext->StyleDisplay()->IsAbsolutelyPositionedStyle())) { + // is only special inside fieldset, check both the frame tree + // parent and content tree parent due to XBL issues. For floated or + // absolutely positioned legends we want to construct by display type and + // not do special legend stuff. + // XXXbz it would be nice if we could just decide this based on the parent + // tag, and hence just use a SIMPLE_TAG_CHAIN for legend below, but the + // fact that with XBL we could end up with this legend element in some + // totally weird insertion point makes that chancy, I think. + return nullptr; + } + + static const FrameConstructionDataByTag sHTMLData[] = { + SIMPLE_TAG_CHAIN(img, nsCSSFrameConstructor::FindImgData), + SIMPLE_TAG_CHAIN(mozgeneratedcontentimage, + nsCSSFrameConstructor::FindImgData), + { &nsGkAtoms::br, + FCDATA_DECL(FCDATA_IS_LINE_PARTICIPANT | FCDATA_IS_LINE_BREAK, + NS_NewBRFrame) }, + SIMPLE_TAG_CREATE(wbr, NS_NewWBRFrame), + SIMPLE_TAG_CHAIN(input, nsCSSFrameConstructor::FindInputData), + SIMPLE_TAG_CREATE(textarea, NS_NewTextControlFrame), + COMPLEX_TAG_CREATE(select, &nsCSSFrameConstructor::ConstructSelectFrame), + SIMPLE_TAG_CHAIN(object, nsCSSFrameConstructor::FindObjectData), + SIMPLE_TAG_CHAIN(applet, nsCSSFrameConstructor::FindObjectData), + SIMPLE_TAG_CHAIN(embed, nsCSSFrameConstructor::FindObjectData), + COMPLEX_TAG_CREATE(fieldset, + &nsCSSFrameConstructor::ConstructFieldSetFrame), + { &nsGkAtoms::legend, + FCDATA_DECL(FCDATA_ALLOW_BLOCK_STYLES | FCDATA_MAY_NEED_SCROLLFRAME, + NS_NewLegendFrame) }, + SIMPLE_TAG_CREATE(frameset, NS_NewHTMLFramesetFrame), + SIMPLE_TAG_CREATE(iframe, NS_NewSubDocumentFrame), + { &nsGkAtoms::button, + FCDATA_WITH_WRAPPING_BLOCK(FCDATA_ALLOW_BLOCK_STYLES, + NS_NewHTMLButtonControlFrame, + nsCSSAnonBoxes::buttonContent) }, + SIMPLE_TAG_CHAIN(canvas, nsCSSFrameConstructor::FindCanvasData), + SIMPLE_TAG_CREATE(video, NS_NewHTMLVideoFrame), + SIMPLE_TAG_CREATE(audio, NS_NewHTMLVideoFrame), + SIMPLE_TAG_CREATE(progress, NS_NewProgressFrame), + SIMPLE_TAG_CREATE(meter, NS_NewMeterFrame) + }; + + return FindDataByTag(aTag, aElement, aStyleContext, sHTMLData, + ArrayLength(sHTMLData)); +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindImgData(Element* aElement, + nsStyleContext* aStyleContext) +{ + if (!nsImageFrame::ShouldCreateImageFrameFor(aElement, aStyleContext)) { + return nullptr; + } + + static const FrameConstructionData sImgData = SIMPLE_FCDATA(NS_NewImageFrame); + return &sImgData; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindImgControlData(Element* aElement, + nsStyleContext* aStyleContext) +{ + if (!nsImageFrame::ShouldCreateImageFrameFor(aElement, aStyleContext)) { + return nullptr; + } + + static const FrameConstructionData sImgControlData = + SIMPLE_FCDATA(NS_NewImageControlFrame); + return &sImgControlData; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindInputData(Element* aElement, + nsStyleContext* aStyleContext) +{ + static const FrameConstructionDataByInt sInputData[] = { + SIMPLE_INT_CREATE(NS_FORM_INPUT_CHECKBOX, NS_NewGfxCheckboxControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_RADIO, NS_NewGfxRadioControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_FILE, NS_NewFileControlFrame), + SIMPLE_INT_CHAIN(NS_FORM_INPUT_IMAGE, + nsCSSFrameConstructor::FindImgControlData), + SIMPLE_INT_CREATE(NS_FORM_INPUT_EMAIL, NS_NewTextControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_SEARCH, NS_NewTextControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_TEXT, NS_NewTextControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_TEL, NS_NewTextControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_URL, NS_NewTextControlFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_RANGE, NS_NewRangeFrame), + SIMPLE_INT_CREATE(NS_FORM_INPUT_PASSWORD, NS_NewTextControlFrame), + { NS_FORM_INPUT_COLOR, + FCDATA_WITH_WRAPPING_BLOCK(0, NS_NewColorControlFrame, + nsCSSAnonBoxes::buttonContent) }, + // TODO: this is temporary until a frame is written: bug 635240. + SIMPLE_INT_CREATE(NS_FORM_INPUT_NUMBER, NS_NewNumberControlFrame), + // TODO: this is temporary until a frame is written: bug 773205. + SIMPLE_INT_CREATE(NS_FORM_INPUT_DATE, NS_NewTextControlFrame), + // TODO: this is temporary until a frame is written: bug 773205 + SIMPLE_INT_CREATE(NS_FORM_INPUT_TIME, NS_NewTextControlFrame), + { NS_FORM_INPUT_SUBMIT, + FCDATA_WITH_WRAPPING_BLOCK(0, NS_NewGfxButtonControlFrame, + nsCSSAnonBoxes::buttonContent) }, + { NS_FORM_INPUT_RESET, + FCDATA_WITH_WRAPPING_BLOCK(0, NS_NewGfxButtonControlFrame, + nsCSSAnonBoxes::buttonContent) }, + { NS_FORM_INPUT_BUTTON, + FCDATA_WITH_WRAPPING_BLOCK(0, NS_NewGfxButtonControlFrame, + nsCSSAnonBoxes::buttonContent) } + // Keeping hidden inputs out of here on purpose for so they get frames by + // display (in practice, none). + }; + + nsCOMPtr control = do_QueryInterface(aElement); + NS_ASSERTION(control, "input doesn't implement nsIFormControl?"); + + return FindDataByInt(control->GetType(), aElement, aStyleContext, + sInputData, ArrayLength(sInputData)); +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindObjectData(Element* aElement, + nsStyleContext* aStyleContext) +{ + // GetDisplayedType isn't necessarily nsIObjectLoadingContent::TYPE_NULL for + // cases when the object is broken/suppressed/etc (e.g. a broken image), but + // we want to treat those cases as TYPE_NULL + uint32_t type; + if (aElement->State().HasAtLeastOneOfStates(NS_EVENT_STATE_BROKEN | + NS_EVENT_STATE_USERDISABLED | + NS_EVENT_STATE_SUPPRESSED)) { + type = nsIObjectLoadingContent::TYPE_NULL; + } else { + nsCOMPtr objContent(do_QueryInterface(aElement)); + NS_ASSERTION(objContent, + "applet, embed and object must implement " + "nsIObjectLoadingContent!"); + + objContent->GetDisplayedType(&type); + } + + static const FrameConstructionDataByInt sObjectData[] = { + SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_LOADING, + NS_NewEmptyFrame), + SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_PLUGIN, + NS_NewObjectFrame), + SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_IMAGE, + NS_NewImageFrame), + SIMPLE_INT_CREATE(nsIObjectLoadingContent::TYPE_DOCUMENT, + NS_NewSubDocumentFrame) + // Nothing for TYPE_NULL so we'll construct frames by display there + }; + + return FindDataByInt((int32_t)type, aElement, aStyleContext, + sObjectData, ArrayLength(sObjectData)); +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindCanvasData(Element* aElement, + nsStyleContext* aStyleContext) +{ + // We want to check whether script is enabled on the document that + // could be painting to the canvas. That's the owner document of + // the canvas, except when the owner document is a static document, + // in which case it's the original document it was cloned from. + nsIDocument* doc = aElement->OwnerDoc(); + if (doc->IsStaticDocument()) { + doc = doc->GetOriginalDocument(); + } + if (!doc->IsScriptEnabled()) { + return nullptr; + } + + static const FrameConstructionData sCanvasData = + FCDATA_WITH_WRAPPING_BLOCK(0, NS_NewHTMLCanvasFrame, + nsCSSAnonBoxes::htmlCanvasContent); + return &sCanvasData; +} + +void +nsCSSFrameConstructor::ConstructFrameFromItemInternal(FrameConstructionItem& aItem, + nsFrameConstructorState& aState, + nsIFrame* aParentFrame, + nsFrameItems& aFrameItems) +{ + const FrameConstructionData* data = aItem.mFCData; + NS_ASSERTION(data, "Must have frame construction data"); + + uint32_t bits = data->mBits; + + NS_ASSERTION(!(bits & FCDATA_FUNC_IS_DATA_GETTER), + "Should have dealt with this inside the data finder"); + + // Some sets of bits are not compatible with each other +#define CHECK_ONLY_ONE_BIT(_bit1, _bit2) \ + NS_ASSERTION(!(bits & _bit1) || !(bits & _bit2), \ + "Only one of these bits should be set") + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_FORCE_NULL_ABSPOS_CONTAINER); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_WRAP_KIDS_IN_BLOCKS); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_MAY_NEED_SCROLLFRAME); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_IS_POPUP); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_SKIP_ABSPOS_PUSH); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, + FCDATA_DISALLOW_GENERATED_CONTENT); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, FCDATA_ALLOW_BLOCK_STYLES); + CHECK_ONLY_ONE_BIT(FCDATA_FUNC_IS_FULL_CTOR, + FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS); + CHECK_ONLY_ONE_BIT(FCDATA_WRAP_KIDS_IN_BLOCKS, + FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS); +#undef CHECK_ONLY_ONE_BIT + NS_ASSERTION(!(bits & FCDATA_FORCED_NON_SCROLLABLE_BLOCK) || + ((bits & FCDATA_FUNC_IS_FULL_CTOR) && + data->mFullConstructor == + &nsCSSFrameConstructor::ConstructNonScrollableBlock), + "Unexpected FCDATA_FORCED_NON_SCROLLABLE_BLOCK flag"); + + // Don't create a subdocument frame for iframes if we're creating extra frames + if (aState.mCreatingExtraFrames && aItem.mContent->IsHTML() && + aItem.mContent->Tag() == nsGkAtoms::iframe) + { + return; + } + + nsStyleContext* const styleContext = aItem.mStyleContext; + const nsStyleDisplay* display = styleContext->StyleDisplay(); + nsIContent* const content = aItem.mContent; + + // Get the parent of the content and check if it is a XBL children element. + // Push the children element as an ancestor here because it does + // not have a frame and would not otherwise be pushed as an ancestor. It is + // necessary to do so in order to correctly handle style resolution on + // descendants. + nsIContent* parent = content->GetParent(); + TreeMatchContext::AutoAncestorPusher + insertionPointPusher(aState.mTreeMatchContext); + if (parent && nsContentUtils::IsContentInsertionPoint(parent)) { + if (aState.mTreeMatchContext.mAncestorFilter.HasFilter()) { + insertionPointPusher.PushAncestorAndStyleScope(parent); + } else { + insertionPointPusher.PushStyleScope(parent); + } + } + + // Push the content as a style ancestor now, so we don't have to do + // it in our various full-constructor functions. In particular, + // since a number of full-constructor functions don't actually call + // ProcessChildren in some cases (e.g. for CSS anonymous table boxes + // or for situations where only anonymouse children are having + // frames constructed), this is the best place to bottleneck the + // pushing of the content instead of having to do it in multiple + // places. + TreeMatchContext::AutoAncestorPusher + ancestorPusher(aState.mTreeMatchContext); + if (aState.mTreeMatchContext.mAncestorFilter.HasFilter()) { + ancestorPusher.PushAncestorAndStyleScope(content); + } else { + ancestorPusher.PushStyleScope(content); + } + + nsIFrame* newFrame; + nsIFrame* primaryFrame; + if (bits & FCDATA_FUNC_IS_FULL_CTOR) { + newFrame = + (this->*(data->mFullConstructor))(aState, aItem, aParentFrame, + display, aFrameItems); + MOZ_ASSERT(newFrame, "Full constructor failed"); + primaryFrame = newFrame; + } else { + newFrame = + (*data->mFunc.mCreationFunc)(mPresShell, styleContext); + + bool allowOutOfFlow = !(bits & FCDATA_DISALLOW_OUT_OF_FLOW); + bool isPopup = aItem.mIsPopup; + NS_ASSERTION(!isPopup || + (aState.mPopupItems.containingBlock && + aState.mPopupItems.containingBlock->GetType() == + nsGkAtoms::popupSetFrame), + "Should have a containing block here!"); + + nsIFrame* geometricParent = + isPopup ? aState.mPopupItems.containingBlock : + (allowOutOfFlow ? aState.GetGeometricParent(display, aParentFrame) + : aParentFrame); + + // Must init frameToAddToList to null, since it's inout + nsIFrame* frameToAddToList = nullptr; + if ((bits & FCDATA_MAY_NEED_SCROLLFRAME) && + display->IsScrollableOverflow()) { + BuildScrollFrame(aState, content, styleContext, newFrame, + geometricParent, frameToAddToList); + } else { + InitAndRestoreFrame(aState, content, geometricParent, newFrame); + // See whether we need to create a view + nsContainerFrame::CreateViewForFrame(newFrame, false); + frameToAddToList = newFrame; + } + + // Use frameToAddToList as the primary frame. In the non-scrollframe case + // they're equal, but in the scrollframe case newFrame is the scrolled + // frame, while frameToAddToList is the scrollframe (and should be the + // primary frame). + primaryFrame = frameToAddToList; + + // If we need to create a block formatting context to wrap our + // kids, do it now. + const nsStyleDisplay* maybeAbsoluteContainingBlockDisplay = display; + nsIFrame* maybeAbsoluteContainingBlock = newFrame; + nsIFrame* possiblyLeafFrame = newFrame; + if (bits & FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS) { + nsRefPtr blockContext; + blockContext = + mPresShell->StyleSet()->ResolveAnonymousBoxStyle(*data->mAnonBoxPseudo, + styleContext); + nsIFrame* blockFrame = + NS_NewBlockFormattingContext(mPresShell, blockContext); + + InitAndRestoreFrame(aState, content, newFrame, blockFrame); + + SetInitialSingleChild(newFrame, blockFrame); + + // Now figure out whether newFrame or blockFrame should be the + // absolute container. It should be the latter if it's + // positioned, otherwise the former. + const nsStyleDisplay* blockDisplay = blockContext->StyleDisplay(); + if (blockDisplay->IsPositioned(blockFrame)) { + maybeAbsoluteContainingBlockDisplay = blockDisplay; + maybeAbsoluteContainingBlock = blockFrame; + } + + // Our kids should go into the blockFrame + newFrame = blockFrame; + } + + aState.AddChild(frameToAddToList, aFrameItems, content, styleContext, + aParentFrame, allowOutOfFlow, allowOutOfFlow, isPopup); + +#ifdef MOZ_XUL + // Icky XUL stuff, sadly + + if (aItem.mIsRootPopupgroup) { + NS_ASSERTION(nsIRootBox::GetRootBox(mPresShell) && + nsIRootBox::GetRootBox(mPresShell)->GetPopupSetFrame() == + newFrame, + "Unexpected PopupSetFrame"); + aState.mPopupItems.containingBlock = newFrame; + aState.mHavePendingPopupgroup = false; + } +#endif /* MOZ_XUL */ + + // Process the child content if requested + nsFrameItems childItems; + nsFrameConstructorSaveState absoluteSaveState; + + if (bits & FCDATA_FORCE_NULL_ABSPOS_CONTAINER) { + aState.PushAbsoluteContainingBlock(nullptr, nullptr, absoluteSaveState); + } else if (!(bits & FCDATA_SKIP_ABSPOS_PUSH)) { + nsIFrame* cb = maybeAbsoluteContainingBlock; + cb->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN); + // This check is identical to nsStyleDisplay::IsPositioned except without + // the assertion that the style display and frame match. When constructing + // scroll frames we intentionally use the style display for the outer, but + // make the inner the containing block. + if ((maybeAbsoluteContainingBlockDisplay->IsAbsolutelyPositionedStyle() || + maybeAbsoluteContainingBlockDisplay->IsRelativelyPositionedStyle() || + (maybeAbsoluteContainingBlockDisplay->HasTransformStyle() && + cb->IsFrameOfType(nsIFrame::eSupportsCSSTransforms)) || + maybeAbsoluteContainingBlockDisplay->HasPerspectiveStyle()) && + !cb->IsSVGText()) { + aState.PushAbsoluteContainingBlock(cb, cb, absoluteSaveState); + } + } + + if (!aItem.mAnonChildren.IsEmpty()) { + NS_ASSERTION(!(bits & FCDATA_USE_CHILD_ITEMS), + "We should not have both anonymous and non-anonymous " + "children in a given FrameConstructorItem"); + AddFCItemsForAnonymousContent(aState, newFrame, aItem.mAnonChildren, + aItem.mChildItems); + bits |= FCDATA_USE_CHILD_ITEMS; + } + + if (bits & FCDATA_USE_CHILD_ITEMS) { + nsFrameConstructorSaveState floatSaveState; + + if (ShouldSuppressFloatingOfDescendants(newFrame)) { + aState.PushFloatContainingBlock(nullptr, floatSaveState); + } else if (newFrame->IsFloatContainingBlock()) { + aState.PushFloatContainingBlock(newFrame, floatSaveState); + } + ConstructFramesFromItemList(aState, aItem.mChildItems, newFrame, + childItems); + } else { + // Process the child frames. + ProcessChildren(aState, content, styleContext, newFrame, + !(bits & FCDATA_DISALLOW_GENERATED_CONTENT), + childItems, + (bits & FCDATA_ALLOW_BLOCK_STYLES) != 0, + aItem.mPendingBinding, possiblyLeafFrame); + } + +#ifdef MOZ_XUL + // More icky XUL stuff + if (aItem.mNameSpaceID == kNameSpaceID_XUL && + (aItem.mTag == nsGkAtoms::treechildren || // trees always need titletips + content->HasAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext) || + content->HasAttr(kNameSpaceID_None, nsGkAtoms::tooltip))) { + nsIRootBox* rootBox = nsIRootBox::GetRootBox(mPresShell); + if (rootBox) { + rootBox->AddTooltipSupport(content); + } + } +#endif + + if (bits & FCDATA_WRAP_KIDS_IN_BLOCKS) { + nsFrameItems newItems; + nsFrameItems currentBlockItems; + nsIFrame* f; + while ((f = childItems.FirstChild()) != nullptr) { + bool wrapFrame = IsInlineFrame(f) || IsFramePartOfIBSplit(f); + if (!wrapFrame) { + FlushAccumulatedBlock(aState, content, newFrame, + currentBlockItems, newItems); + } + + childItems.RemoveFrame(f); + if (wrapFrame) { + currentBlockItems.AddChild(f); + } else { + newItems.AddChild(f); + } + } + FlushAccumulatedBlock(aState, content, newFrame, + currentBlockItems, newItems); + + if (childItems.NotEmpty()) { + // an error must have occurred, delete unprocessed frames + childItems.DestroyFrames(); + } + + childItems = newItems; + } + + // Set the frame's initial child list + // Note that MathML depends on this being called even if + // childItems is empty! + newFrame->SetInitialChildList(kPrincipalList, childItems); + } + + NS_ASSERTION(newFrame->IsFrameOfType(nsIFrame::eLineParticipant) == + ((bits & FCDATA_IS_LINE_PARTICIPANT) != 0), + "Incorrectly set FCDATA_IS_LINE_PARTICIPANT bits"); + + if (aItem.mIsAnonymousContentCreatorContent) { + primaryFrame->AddStateBits(NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT); + } + + // Even if mCreatingExtraFrames is set, we may need to SetPrimaryFrame for + // generated content that doesn't have one yet. Note that we have to examine + // the frame bit, because by this point mIsGeneratedContent has been cleared + // on aItem. + if ((!aState.mCreatingExtraFrames || + ((primaryFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT) && + !aItem.mContent->GetPrimaryFrame())) && + !(bits & FCDATA_SKIP_FRAMESET)) { + aItem.mContent->SetPrimaryFrame(primaryFrame); + } +} + +// after the node has been constructed and initialized create any +// anonymous content a node needs. +nsresult +nsCSSFrameConstructor::CreateAnonymousFrames(nsFrameConstructorState& aState, + nsIContent* aParent, + nsIFrame* aParentFrame, + PendingBinding* aPendingBinding, + nsFrameItems& aChildItems) +{ + nsAutoTArray newAnonymousItems; + nsresult rv = GetAnonymousContent(aParent, aParentFrame, newAnonymousItems); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t count = newAnonymousItems.Length(); + if (count == 0) { + return NS_OK; + } + + nsFrameConstructorState::PendingBindingAutoPusher pusher(aState, + aPendingBinding); + TreeMatchContext::AutoAncestorPusher ancestorPusher(aState.mTreeMatchContext); + if (aState.mTreeMatchContext.mAncestorFilter.HasFilter()) { + ancestorPusher.PushAncestorAndStyleScope(aParent->AsElement()); + } else { + ancestorPusher.PushStyleScope(aParent->AsElement()); + } + + nsIAnonymousContentCreator* creator = do_QueryFrame(aParentFrame); + NS_ASSERTION(creator, + "How can that happen if we have nodes to construct frames for?"); + + for (uint32_t i=0; i < count; i++) { + nsIContent* content = newAnonymousItems[i].mContent; + NS_ASSERTION(content, "null anonymous content?"); + NS_ASSERTION(!newAnonymousItems[i].mStyleContext, "Unexpected style context"); + NS_ASSERTION(newAnonymousItems[i].mChildren.IsEmpty(), + "This method is not currently used with frames that implement " + "nsIAnonymousContentCreator::CreateAnonymousContent to " + "output a list where the items have their own children"); + + nsIFrame* newFrame = creator->CreateFrameFor(content); + if (newFrame) { + NS_ASSERTION(content->GetPrimaryFrame(), + "Content must have a primary frame now"); + newFrame->AddStateBits(NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT); + aChildItems.AddChild(newFrame); + } else { + FrameConstructionItemList items; + { + // Skip flex item style-fixup during our AddFrameConstructionItems() call: + TreeMatchContext::AutoFlexItemStyleFixupSkipper + flexItemStyleFixupSkipper(aState.mTreeMatchContext); + + AddFrameConstructionItems(aState, content, true, aParentFrame, items); + } + ConstructFramesFromItemList(aState, items, aParentFrame, aChildItems); + } + } + + return NS_OK; +} + +static void +SetFlagsOnSubtree(nsIContent *aNode, uintptr_t aFlagsToSet) +{ +#ifdef DEBUG + // Make sure that the node passed to us doesn't have any XBL children + { + FlattenedChildIterator iter(aNode); + NS_ASSERTION(!iter.XBLInvolved() || !iter.GetNextChild(), + "The node should not have any XBL children"); + } +#endif + + // Set the flag on the node itself + aNode->SetFlags(aFlagsToSet); + + // Set the flag on all of its children recursively + uint32_t count; + nsIContent * const *children = aNode->GetChildArray(&count); + + for (uint32_t index = 0; index < count; ++index) { + SetFlagsOnSubtree(children[index], aFlagsToSet); + } +} + +/** + * This function takes a tree of nsIAnonymousContentCreator::ContentInfo + * objects where the nsIContent nodes have just been created, and appends the + * nsIContent children in the tree to their parent. The leaf nsIContent objects + * are appended first to minimize the number of notifications that are sent + * out (i.e. by appending as many descendants as posible while their parent is + * not yet in the document tree). + * + * This function is used simply as a convenience so that implementations of + * nsIAnonymousContentCreator::CreateAnonymousContent don't all have to have + * their own code to connect the elements that they create. + */ +static void +ConnectAnonymousTreeDescendants(nsIContent* aParent, + nsTArray& aContent) +{ + uint32_t count = aContent.Length(); + for (uint32_t i=0; i < count; i++) { + nsIContent* content = aContent[i].mContent; + NS_ASSERTION(content, "null anonymous content?"); + + ConnectAnonymousTreeDescendants(content, aContent[i].mChildren); + + aParent->AppendChildTo(content, false); + } +} + +nsresult +nsCSSFrameConstructor::GetAnonymousContent(nsIContent* aParent, + nsIFrame* aParentFrame, + nsTArray& aContent) +{ + nsIAnonymousContentCreator* creator = do_QueryFrame(aParentFrame); + if (!creator) + return NS_OK; + + nsresult rv = creator->CreateAnonymousContent(aContent); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t count = aContent.Length(); + for (uint32_t i=0; i < count; i++) { + // get our child's content and set its parent to our content + nsIContent* content = aContent[i].mContent; + NS_ASSERTION(content, "null anonymous content?"); + + // least-surprise CSS binding until we do the SVG specified + // cascading rules for - bug 265894 + if (aParentFrame->GetType() == nsGkAtoms::svgUseFrame) { + content->SetFlags(NODE_IS_ANONYMOUS_ROOT); + } else { + content->SetIsNativeAnonymousRoot(); + } + + ConnectAnonymousTreeDescendants(content, aContent[i].mChildren); + + bool anonContentIsEditable = content->HasFlag(NODE_IS_EDITABLE); + rv = content->BindToTree(mDocument, aParent, aParent, true); + // If the anonymous content creator requested that the content should be + // editable, honor its request. + // We need to set the flag on the whole subtree, because existing + // children's flags have already been set as part of the BindToTree operation. + if (anonContentIsEditable) { + NS_ASSERTION(aParentFrame->GetType() == nsGkAtoms::textInputFrame, + "We only expect this for anonymous content under a text control frame"); + SetFlagsOnSubtree(content, NODE_IS_EDITABLE); + } + if (NS_FAILED(rv)) { + content->UnbindFromTree(); + return rv; + } + } + + return NS_OK; +} + +static +bool IsXULDisplayType(const nsStyleDisplay* aDisplay) +{ + return (aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_BOX || +#ifdef MOZ_XUL + aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_XUL_GRID || + aDisplay->mDisplay == NS_STYLE_DISPLAY_INLINE_STACK || +#endif + aDisplay->mDisplay == NS_STYLE_DISPLAY_BOX +#ifdef MOZ_XUL + || aDisplay->mDisplay == NS_STYLE_DISPLAY_XUL_GRID || + aDisplay->mDisplay == NS_STYLE_DISPLAY_STACK || + aDisplay->mDisplay == NS_STYLE_DISPLAY_XUL_GRID_GROUP || + aDisplay->mDisplay == NS_STYLE_DISPLAY_XUL_GRID_LINE || + aDisplay->mDisplay == NS_STYLE_DISPLAY_DECK || + aDisplay->mDisplay == NS_STYLE_DISPLAY_POPUP || + aDisplay->mDisplay == NS_STYLE_DISPLAY_GROUPBOX +#endif + ); +} + + +// XUL frames are not allowed to be out of flow. +#define SIMPLE_XUL_FCDATA(_func) \ + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH, \ + _func) +#define SCROLLABLE_XUL_FCDATA(_func) \ + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH | \ + FCDATA_MAY_NEED_SCROLLFRAME, _func) +// .. but we allow some XUL frames to be _containers_ for out-of-flow content +// (This is the same as SCROLLABLE_XUL_FCDATA, but w/o FCDATA_SKIP_ABSPOS_PUSH) +#define SCROLLABLE_ABSPOS_CONTAINER_XUL_FCDATA(_func) \ + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \ + FCDATA_MAY_NEED_SCROLLFRAME, _func) + +#define SIMPLE_XUL_CREATE(_tag, _func) \ + { &nsGkAtoms::_tag, SIMPLE_XUL_FCDATA(_func) } +#define SCROLLABLE_XUL_CREATE(_tag, _func) \ + { &nsGkAtoms::_tag, SCROLLABLE_XUL_FCDATA(_func) } +#define SIMPLE_XUL_INT_CREATE(_int, _func) \ + { _int, SIMPLE_XUL_FCDATA(_func) } +#define SCROLLABLE_XUL_INT_CREATE(_int, _func) \ + { _int, SCROLLABLE_XUL_FCDATA(_func) } +#define SCROLLABLE_ABSPOS_CONTAINER_XUL_INT_CREATE(_int, _func) \ + { _int, SCROLLABLE_ABSPOS_CONTAINER_XUL_FCDATA(_func) } + +static +nsIFrame* NS_NewGridBoxFrame(nsIPresShell* aPresShell, + nsStyleContext* aStyleContext) +{ + nsCOMPtr layout; + NS_NewGridLayout2(aPresShell, getter_AddRefs(layout)); + return NS_NewBoxFrame(aPresShell, aStyleContext, false, layout); +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULTagData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsStyleContext* aStyleContext) +{ + if (aNameSpaceID != kNameSpaceID_XUL) { + return nullptr; + } + + static const FrameConstructionDataByTag sXULTagData[] = { +#ifdef MOZ_XUL + SCROLLABLE_XUL_CREATE(button, NS_NewButtonBoxFrame), + SCROLLABLE_XUL_CREATE(checkbox, NS_NewButtonBoxFrame), + SCROLLABLE_XUL_CREATE(radio, NS_NewButtonBoxFrame), + SCROLLABLE_XUL_CREATE(autorepeatbutton, NS_NewAutoRepeatBoxFrame), + SCROLLABLE_XUL_CREATE(titlebar, NS_NewTitleBarFrame), + SCROLLABLE_XUL_CREATE(resizer, NS_NewResizerFrame), + SIMPLE_XUL_CREATE(image, NS_NewImageBoxFrame), + SIMPLE_XUL_CREATE(spring, NS_NewLeafBoxFrame), + SIMPLE_XUL_CREATE(spacer, NS_NewLeafBoxFrame), + SIMPLE_XUL_CREATE(treechildren, NS_NewTreeBodyFrame), + SIMPLE_XUL_CREATE(treecol, NS_NewTreeColFrame), + SIMPLE_XUL_CREATE(text, NS_NewTextBoxFrame), + SIMPLE_TAG_CHAIN(label, nsCSSFrameConstructor::FindXULLabelData), + SIMPLE_TAG_CHAIN(description, nsCSSFrameConstructor::FindXULDescriptionData), + SIMPLE_XUL_CREATE(menu, NS_NewMenuFrame), + SIMPLE_XUL_CREATE(menubutton, NS_NewMenuFrame), + SIMPLE_XUL_CREATE(menuitem, NS_NewMenuItemFrame), +#ifdef XP_MACOSX + SIMPLE_TAG_CHAIN(menubar, nsCSSFrameConstructor::FindXULMenubarData), +#else + SIMPLE_XUL_CREATE(menubar, NS_NewMenuBarFrame), +#endif /* XP_MACOSX */ + SIMPLE_TAG_CHAIN(popupgroup, nsCSSFrameConstructor::FindPopupGroupData), + SIMPLE_XUL_CREATE(iframe, NS_NewSubDocumentFrame), + SIMPLE_XUL_CREATE(editor, NS_NewSubDocumentFrame), + SIMPLE_XUL_CREATE(browser, NS_NewSubDocumentFrame), + SIMPLE_XUL_CREATE(progressmeter, NS_NewProgressMeterFrame), + SIMPLE_XUL_CREATE(splitter, NS_NewSplitterFrame), + SIMPLE_TAG_CHAIN(listboxbody, + nsCSSFrameConstructor::FindXULListBoxBodyData), + SIMPLE_TAG_CHAIN(listitem, nsCSSFrameConstructor::FindXULListItemData), +#endif /* MOZ_XUL */ + SIMPLE_XUL_CREATE(slider, NS_NewSliderFrame), + SIMPLE_XUL_CREATE(scrollbar, NS_NewScrollbarFrame), + SIMPLE_XUL_CREATE(scrollbarbutton, NS_NewScrollbarButtonFrame) +}; + + return FindDataByTag(aTag, aElement, aStyleContext, sXULTagData, + ArrayLength(sXULTagData)); +} + +#ifdef MOZ_XUL +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindPopupGroupData(Element* aElement, + nsStyleContext* /* unused */) +{ + if (!aElement->IsRootOfNativeAnonymousSubtree()) { + return nullptr; + } + + static const FrameConstructionData sPopupSetData = + SIMPLE_XUL_FCDATA(NS_NewPopupSetFrame); + return &sPopupSetData; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData +nsCSSFrameConstructor::sXULTextBoxData = SIMPLE_XUL_FCDATA(NS_NewTextBoxFrame); + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULLabelData(Element* aElement, + nsStyleContext* /* unused */) +{ + if (aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::value)) { + return &sXULTextBoxData; + } + + static const FrameConstructionData sLabelData = + SIMPLE_XUL_FCDATA(NS_NewXULLabelFrame); + return &sLabelData; +} + +static nsIFrame* +NS_NewXULDescriptionFrame(nsIPresShell* aPresShell, nsStyleContext *aContext) +{ + // XXXbz do we really need to set those flags? If the parent is not + // a block we'll get them anyway, and if it is, do we want them? + return NS_NewBlockFrame(aPresShell, aContext, + NS_BLOCK_FLOAT_MGR | NS_BLOCK_MARGIN_ROOT); +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULDescriptionData(Element* aElement, + nsStyleContext* /* unused */) +{ + if (aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::value)) { + return &sXULTextBoxData; + } + + static const FrameConstructionData sDescriptionData = + SIMPLE_XUL_FCDATA(NS_NewXULDescriptionFrame); + return &sDescriptionData; +} + +#ifdef XP_MACOSX +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULMenubarData(Element* aElement, + nsStyleContext* aStyleContext) +{ + nsCOMPtr treeItem = + aStyleContext->PresContext()->GetDocShell(); + if (treeItem && nsIDocShellTreeItem::typeChrome == treeItem->ItemType()) { + nsCOMPtr parent; + treeItem->GetParent(getter_AddRefs(parent)); + if (!parent) { + // This is the root. Suppress the menubar, since on Mac + // window menus are not attached to the window. + static const FrameConstructionData sSuppressData = SUPPRESS_FCDATA(); + return &sSuppressData; + } + } + + static const FrameConstructionData sMenubarData = + SIMPLE_XUL_FCDATA(NS_NewMenuBarFrame); + return &sMenubarData; +} +#endif /* XP_MACOSX */ + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULListBoxBodyData(Element* aElement, + nsStyleContext* aStyleContext) +{ + if (aStyleContext->StyleDisplay()->mDisplay != + NS_STYLE_DISPLAY_XUL_GRID_GROUP) { + return nullptr; + } + + static const FrameConstructionData sListBoxBodyData = + SCROLLABLE_XUL_FCDATA(NS_NewListBoxBodyFrame); + return &sListBoxBodyData; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULListItemData(Element* aElement, + nsStyleContext* aStyleContext) +{ + if (aStyleContext->StyleDisplay()->mDisplay != + NS_STYLE_DISPLAY_XUL_GRID_LINE) { + return nullptr; + } + + static const FrameConstructionData sListItemData = + SCROLLABLE_XUL_FCDATA(NS_NewListItemFrame); + return &sListItemData; +} + +#endif /* MOZ_XUL */ + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindXULDisplayData(const nsStyleDisplay* aDisplay, + Element* aElement, + nsStyleContext* aStyleContext) +{ + static const FrameConstructionDataByInt sXULDisplayData[] = { + SCROLLABLE_ABSPOS_CONTAINER_XUL_INT_CREATE(NS_STYLE_DISPLAY_INLINE_BOX, + NS_NewBoxFrame), + SCROLLABLE_ABSPOS_CONTAINER_XUL_INT_CREATE(NS_STYLE_DISPLAY_BOX, + NS_NewBoxFrame), +#ifdef MOZ_XUL + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_INLINE_XUL_GRID, NS_NewGridBoxFrame), + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_XUL_GRID, NS_NewGridBoxFrame), + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_XUL_GRID_GROUP, + NS_NewGridRowGroupFrame), + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_XUL_GRID_LINE, + NS_NewGridRowLeafFrame), + SIMPLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_DECK, NS_NewDeckFrame), + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_GROUPBOX, NS_NewGroupBoxFrame), + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_INLINE_STACK, NS_NewStackFrame), + SCROLLABLE_XUL_INT_CREATE(NS_STYLE_DISPLAY_STACK, NS_NewStackFrame), + { NS_STYLE_DISPLAY_POPUP, + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_IS_POPUP | + FCDATA_SKIP_ABSPOS_PUSH, NS_NewMenuPopupFrame) } +#endif /* MOZ_XUL */ + }; + + // Processing by display here: + return FindDataByInt(aDisplay->mDisplay, aElement, aStyleContext, + sXULDisplayData, ArrayLength(sXULDisplayData)); +} + +already_AddRefed +nsCSSFrameConstructor::BeginBuildingScrollFrame(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aContentStyle, + nsIFrame* aParentFrame, + nsIAtom* aScrolledPseudo, + bool aIsRoot, + nsIFrame*& aNewFrame) +{ + nsIFrame* gfxScrollFrame = aNewFrame; + + nsFrameItems anonymousItems; + + nsRefPtr contentStyle = aContentStyle; + + if (!gfxScrollFrame) { + // Build a XULScrollFrame when the child is a box, otherwise an + // HTMLScrollFrame + // XXXbz this is the lone remaining consumer of IsXULDisplayType. + // I wonder whether we can eliminate that somehow. + const nsStyleDisplay* displayStyle = aContentStyle->StyleDisplay(); + if (IsXULDisplayType(displayStyle)) { + gfxScrollFrame = NS_NewXULScrollFrame(mPresShell, contentStyle, aIsRoot, + displayStyle->mDisplay == NS_STYLE_DISPLAY_STACK || + displayStyle->mDisplay == NS_STYLE_DISPLAY_INLINE_STACK); + } else { + gfxScrollFrame = NS_NewHTMLScrollFrame(mPresShell, contentStyle, aIsRoot); + } + + InitAndRestoreFrame(aState, aContent, aParentFrame, gfxScrollFrame); + } + + // if there are any anonymous children for the scroll frame, create + // frames for them. + // Pass a null pending binding: we don't care how constructors for any of + // this anonymous content order with anything else. It's never been + // consistent anyway. + CreateAnonymousFrames(aState, aContent, gfxScrollFrame, nullptr, + anonymousItems); + + aNewFrame = gfxScrollFrame; + + // we used the style that was passed in. So resolve another one. + nsStyleSet *styleSet = mPresShell->StyleSet(); + nsRefPtr scrolledChildStyle = + styleSet->ResolveAnonymousBoxStyle(aScrolledPseudo, contentStyle); + + if (gfxScrollFrame) { + gfxScrollFrame->SetInitialChildList(kPrincipalList, anonymousItems); + } + + return scrolledChildStyle.forget(); +} + +void +nsCSSFrameConstructor::FinishBuildingScrollFrame(nsIFrame* aScrollFrame, + nsIFrame* aScrolledFrame) +{ + nsFrameList scrolled(aScrolledFrame, aScrolledFrame); + aScrollFrame->AppendFrames(kPrincipalList, scrolled); +} + + +/** + * Called to wrap a gfx scrollframe around a frame. The hierarchy will look like this + * + * ------- for gfx scrollbars ------ + * + * + * ScrollFrame + * ^ + * | + * Frame (scrolled frame you passed in) + * + * + *----------------------------------- + * LEGEND: + * + * ScrollFrame: This is a frame that manages gfx cross platform frame based scrollbars. + * + * @param aContent the content node of the child to wrap. + * @param aScrolledFrame The frame of the content to wrap. This should not be + * Initialized. This method will initialize it with a scrolled pseudo + * and no nsIContent. The content will be attached to the scrollframe + * returned. + * @param aContentStyle the style context that has already been resolved for the content being passed in. + * + * @param aParentFrame The parent to attach the scroll frame to + * + * @param aNewFrame The new scrollframe or gfx scrollframe that we create. It will contain the + * scrolled frame you passed in. (returned) + * If this is not null, we'll just use it + * @param aScrolledContentStyle the style that was resolved for the scrolled frame. (returned) + */ +nsresult +nsCSSFrameConstructor::BuildScrollFrame(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aContentStyle, + nsIFrame* aScrolledFrame, + nsIFrame* aParentFrame, + nsIFrame*& aNewFrame) +{ + nsRefPtr scrolledContentStyle = + BeginBuildingScrollFrame(aState, aContent, aContentStyle, aParentFrame, + nsCSSAnonBoxes::scrolledContent, + false, aNewFrame); + + aScrolledFrame->SetStyleContextWithoutNotification(scrolledContentStyle); + InitAndRestoreFrame(aState, aContent, aNewFrame, aScrolledFrame); + + FinishBuildingScrollFrame(aNewFrame, aScrolledFrame); + return NS_OK; +} + +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindDisplayData(const nsStyleDisplay* aDisplay, + Element* aElement, + nsIFrame* aParentFrame, + nsStyleContext* aStyleContext) +{ + PR_STATIC_ASSERT(eParentTypeCount < (1 << (32 - FCDATA_PARENT_TYPE_OFFSET))); + + // The style system ensures that floated and positioned frames are + // block-level. + NS_ASSERTION(!(aDisplay->IsFloatingStyle() || + aDisplay->IsAbsolutelyPositionedStyle()) || + aDisplay->IsBlockOutsideStyle(), + "Style system did not apply CSS2.1 section 9.7 fixups"); + + // If this is "body", try propagating its scroll style to the viewport + // Note that we need to do this even if the body is NOT scrollable; + // it might have dynamically changed from scrollable to not scrollable, + // and that might need to be propagated. + // XXXbz is this the right place to do this? If this code moves, + // make this function static. + bool propagatedScrollToViewport = false; + if (aElement->IsHTML(nsGkAtoms::body)) { + propagatedScrollToViewport = + PropagateScrollToViewport() == aElement; + } + + NS_ASSERTION(!propagatedScrollToViewport || + !mPresShell->GetPresContext()->IsPaginated(), + "Shouldn't propagate scroll in paginated contexts"); + + // If the frame is a block-level frame and is scrollable, then wrap it in a + // scroll frame. + // XXX Ignore tables for the time being + // XXXbz it would be nice to combine this with the other block + // case... Think about how do do this? + if (aDisplay->IsBlockInsideStyle() && + aDisplay->IsScrollableOverflow() && + !propagatedScrollToViewport) { + // Except we don't want to do that for paginated contexts for + // frames that are block-outside and aren't frames for native + // anonymous stuff. + if (mPresShell->GetPresContext()->IsPaginated() && + aDisplay->IsBlockOutsideStyle() && + !aElement->IsInNativeAnonymousSubtree()) { + static const FrameConstructionData sForcedNonScrollableBlockData = + FULL_CTOR_FCDATA(FCDATA_FORCED_NON_SCROLLABLE_BLOCK, + &nsCSSFrameConstructor::ConstructNonScrollableBlock); + return &sForcedNonScrollableBlockData; + } + + static const FrameConstructionData sScrollableBlockData = + FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructScrollableBlock); + return &sScrollableBlockData; + } + + // Handle various non-scrollable blocks + if (aDisplay->IsBlockInsideStyle()) { + static const FrameConstructionData sNonScrollableBlockData = + FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructNonScrollableBlock); + return &sNonScrollableBlockData; + } + + static const FrameConstructionDataByInt sDisplayData[] = { + // To keep the hash table small don't add inline frames (they're + // typically things like FONT and B), because we can quickly + // find them if we need to. + // XXXbz the "quickly" part is a bald-faced lie! + { NS_STYLE_DISPLAY_INLINE, + FULL_CTOR_FCDATA(FCDATA_IS_INLINE | FCDATA_IS_LINE_PARTICIPANT, + &nsCSSFrameConstructor::ConstructInline) }, + { NS_STYLE_DISPLAY_FLEX, + FCDATA_DECL(FCDATA_MAY_NEED_SCROLLFRAME, NS_NewFlexContainerFrame) }, + { NS_STYLE_DISPLAY_INLINE_FLEX, + FCDATA_DECL(FCDATA_MAY_NEED_SCROLLFRAME, NS_NewFlexContainerFrame) }, + { NS_STYLE_DISPLAY_GRID, + FCDATA_DECL(FCDATA_MAY_NEED_SCROLLFRAME, NS_NewGridContainerFrame) }, + { NS_STYLE_DISPLAY_INLINE_GRID, + FCDATA_DECL(FCDATA_MAY_NEED_SCROLLFRAME, NS_NewGridContainerFrame) }, + { NS_STYLE_DISPLAY_TABLE, + FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructTable) }, + { NS_STYLE_DISPLAY_INLINE_TABLE, + FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructTable) }, + // NOTE: In the unlikely event that we add another table-part here that has + // a desired-parent-type (& hence triggers table fixup), we'll need to also + // update the flexbox chunk in nsStyleContext::ApplyStyleFixups(). + { NS_STYLE_DISPLAY_TABLE_CAPTION, + FCDATA_DECL(FCDATA_IS_TABLE_PART | FCDATA_ALLOW_BLOCK_STYLES | + FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_SKIP_ABSPOS_PUSH | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + NS_NewTableCaptionFrame) }, + { NS_STYLE_DISPLAY_TABLE_ROW_GROUP, + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + &nsCSSFrameConstructor::ConstructTableRowOrRowGroup) }, + { NS_STYLE_DISPLAY_TABLE_HEADER_GROUP, + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + &nsCSSFrameConstructor::ConstructTableRowOrRowGroup) }, + { NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP, + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + &nsCSSFrameConstructor::ConstructTableRowOrRowGroup) }, + { NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP, + FCDATA_DECL(FCDATA_IS_TABLE_PART | FCDATA_DISALLOW_OUT_OF_FLOW | + FCDATA_SKIP_ABSPOS_PUSH | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + NS_NewTableColGroupFrame) }, + { NS_STYLE_DISPLAY_TABLE_COLUMN, + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeColGroup), + &nsCSSFrameConstructor::ConstructTableCol) }, + { NS_STYLE_DISPLAY_TABLE_ROW, + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeRowGroup), + &nsCSSFrameConstructor::ConstructTableRowOrRowGroup) }, + { NS_STYLE_DISPLAY_TABLE_CELL, + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeRow), + &nsCSSFrameConstructor::ConstructTableCell) } + }; + + return FindDataByInt(aDisplay->mDisplay, + aElement, aStyleContext, sDisplayData, + ArrayLength(sDisplayData)); +} + +nsIFrame* +nsCSSFrameConstructor::ConstructScrollableBlock(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems) +{ + nsIContent* const content = aItem.mContent; + nsStyleContext* const styleContext = aItem.mStyleContext; + + nsIFrame* newFrame = nullptr; + nsRefPtr scrolledContentStyle + = BeginBuildingScrollFrame(aState, content, styleContext, + aState.GetGeometricParent(aDisplay, aParentFrame), + nsCSSAnonBoxes::scrolledContent, + false, newFrame); + + // Create our block frame + // pass a temporary stylecontext, the correct one will be set later + nsIFrame* scrolledFrame = + NS_NewBlockFormattingContext(mPresShell, styleContext); + + // Make sure to AddChild before we call ConstructBlock so that we + // end up before our descendants in fixed-pos lists as needed. + aState.AddChild(newFrame, aFrameItems, content, styleContext, aParentFrame); + + nsFrameItems blockItem; + ConstructBlock(aState, scrolledContentStyle->StyleDisplay(), content, + newFrame, newFrame, scrolledContentStyle, + &scrolledFrame, blockItem, + aDisplay->IsPositioned(newFrame) ? newFrame : nullptr, + aItem.mPendingBinding); + + NS_ASSERTION(blockItem.FirstChild() == scrolledFrame, + "Scrollframe's frameItems should be exactly the scrolled frame"); + FinishBuildingScrollFrame(newFrame, scrolledFrame); + + return newFrame; +} + +nsIFrame* +nsCSSFrameConstructor::ConstructNonScrollableBlock(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems) +{ + nsStyleContext* const styleContext = aItem.mStyleContext; + + // We want a block formatting context root in paginated contexts for + // every block that would be scrollable in a non-paginated context. + // We mark our blocks with a bit here if this condition is true, so + // we can check it later in nsFrame::ApplyPaginatedOverflowClipping. + bool clipPaginatedOverflow = + (aItem.mFCData->mBits & FCDATA_FORCED_NON_SCROLLABLE_BLOCK) != 0; + nsIFrame* newFrame; + if ((aDisplay->IsAbsolutelyPositionedStyle() || + aDisplay->IsFloatingStyle() || + NS_STYLE_DISPLAY_INLINE_BLOCK == aDisplay->mDisplay || + clipPaginatedOverflow) && + !aParentFrame->IsSVGText()) { + newFrame = NS_NewBlockFormattingContext(mPresShell, styleContext); + if (clipPaginatedOverflow) { + newFrame->AddStateBits(NS_BLOCK_CLIP_PAGINATED_OVERFLOW); + } + } else { + newFrame = NS_NewBlockFrame(mPresShell, styleContext); + } + + ConstructBlock(aState, aDisplay, aItem.mContent, + aState.GetGeometricParent(aDisplay, aParentFrame), + aParentFrame, styleContext, &newFrame, + aFrameItems, + aDisplay->IsPositioned(newFrame) ? newFrame : nullptr, + aItem.mPendingBinding); + return newFrame; +} + + +void +nsCSSFrameConstructor::InitAndRestoreFrame(const nsFrameConstructorState& aState, + nsIContent* aContent, + nsIFrame* aParentFrame, + nsIFrame* aNewFrame, + bool aAllowCounters) +{ + NS_PRECONDITION(mUpdateCount != 0, + "Should be in an update while creating frames"); + + MOZ_ASSERT(aNewFrame, "Null frame cannot be initialized"); + + // Initialize the frame + aNewFrame->Init(aContent, aParentFrame, nullptr); + aNewFrame->AddStateBits(aState.mAdditionalStateBits); + + if (aState.mFrameState) { + // Restore frame state for just the newly created frame. + RestoreFrameStateFor(aNewFrame, aState.mFrameState); + } + + if (aAllowCounters && + mCounterManager.AddCounterResetsAndIncrements(aNewFrame)) { + CountersDirty(); + } +} + +already_AddRefed +nsCSSFrameConstructor::ResolveStyleContext(nsIFrame* aParentFrame, + nsIContent* aContent, + nsFrameConstructorState* aState) +{ + nsStyleContext* parentStyleContext = nullptr; + NS_ASSERTION(aContent->GetParent(), "Must have parent here"); + + aParentFrame = nsFrame::CorrectStyleParentFrame(aParentFrame, nullptr); + + if (aParentFrame) { + // Resolve the style context based on the content object and the parent + // style context + parentStyleContext = aParentFrame->StyleContext(); + } else { + // Perhaps aParentFrame is a canvasFrame and we're replicating + // fixed-pos frames. + // XXX should we create a way to tell ConstructFrame which style + // context to use, and pass it the style context for the + // previous page's fixed-pos frame? + } + + return ResolveStyleContext(parentStyleContext, aContent, aState); +} + +already_AddRefed +nsCSSFrameConstructor::ResolveStyleContext(nsStyleContext* aParentStyleContext, + nsIContent* aContent, + nsFrameConstructorState* aState) +{ + nsStyleSet *styleSet = mPresShell->StyleSet(); + aContent->OwnerDoc()->FlushPendingLinkUpdates(); + + if (aContent->IsElement()) { + if (aState) { + return styleSet->ResolveStyleFor(aContent->AsElement(), + aParentStyleContext, + aState->mTreeMatchContext); + } + return styleSet->ResolveStyleFor(aContent->AsElement(), aParentStyleContext); + + } + + NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT), + "shouldn't waste time creating style contexts for " + "comments and processing instructions"); + + return styleSet->ResolveStyleForNonElement(aParentStyleContext); +} + +// MathML Mod - RBS +void +nsCSSFrameConstructor::FlushAccumulatedBlock(nsFrameConstructorState& aState, + nsIContent* aContent, + nsIFrame* aParentFrame, + nsFrameItems& aBlockItems, + nsFrameItems& aNewItems) +{ + if (aBlockItems.IsEmpty()) { + // Nothing to do + return; + } + + nsIAtom* anonPseudo = nsCSSAnonBoxes::mozMathMLAnonymousBlock; + + nsStyleContext* parentContext = + nsFrame::CorrectStyleParentFrame(aParentFrame, + anonPseudo)->StyleContext(); + nsStyleSet* styleSet = mPresShell->StyleSet(); + nsRefPtr blockContext; + blockContext = styleSet-> + ResolveAnonymousBoxStyle(anonPseudo, parentContext); + + + // then, create a block frame that will wrap the child frames. Make it a + // MathML frame so that Get(Absolute/Float)ContainingBlockFor know that this + // is not a suitable block. + nsIFrame* blockFrame = + NS_NewMathMLmathBlockFrame(mPresShell, blockContext, + NS_BLOCK_FLOAT_MGR | NS_BLOCK_MARGIN_ROOT); + + InitAndRestoreFrame(aState, aContent, aParentFrame, blockFrame); + ReparentFrames(this, blockFrame, aBlockItems); + // abs-pos and floats are disabled in MathML children so we don't have to + // worry about messing up those. + blockFrame->SetInitialChildList(kPrincipalList, aBlockItems); + NS_ASSERTION(aBlockItems.IsEmpty(), "What happened?"); + aBlockItems.Clear(); + aNewItems.AddChild(blockFrame); +} + +// Only elements can be floated or positioned. All other MathML +// should be in-flow. +#define SIMPLE_MATHML_CREATE(_tag, _func) \ + { &nsGkAtoms::_tag, \ + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \ + FCDATA_FORCE_NULL_ABSPOS_CONTAINER | \ + FCDATA_WRAP_KIDS_IN_BLOCKS, _func) } + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindMathMLData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsStyleContext* aStyleContext) +{ + // Make sure that we remain confined in the MathML world + if (aNameSpaceID != kNameSpaceID_MathML) + return nullptr; + + // Handle specially, because it sometimes produces inlines + if (aTag == nsGkAtoms::math) { + // This needs to match the test in EnsureBlockDisplay in + // nsRuleNode.cpp. Though the behavior here for the display:table + // case is pretty weird... + if (aStyleContext->StyleDisplay()->IsBlockOutsideStyle()) { + static const FrameConstructionData sBlockMathData = + FCDATA_DECL(FCDATA_FORCE_NULL_ABSPOS_CONTAINER | + FCDATA_WRAP_KIDS_IN_BLOCKS, + NS_CreateNewMathMLmathBlockFrame); + return &sBlockMathData; + } + + static const FrameConstructionData sInlineMathData = + FCDATA_DECL(FCDATA_FORCE_NULL_ABSPOS_CONTAINER | + FCDATA_IS_LINE_PARTICIPANT | + FCDATA_WRAP_KIDS_IN_BLOCKS, + NS_NewMathMLmathInlineFrame); + return &sInlineMathData; + } + + + static const FrameConstructionDataByTag sMathMLData[] = { + SIMPLE_MATHML_CREATE(annotation_, NS_NewMathMLTokenFrame), + SIMPLE_MATHML_CREATE(annotation_xml_, NS_NewMathMLmrowFrame), + SIMPLE_MATHML_CREATE(mi_, NS_NewMathMLTokenFrame), + SIMPLE_MATHML_CREATE(mn_, NS_NewMathMLTokenFrame), + SIMPLE_MATHML_CREATE(ms_, NS_NewMathMLTokenFrame), + SIMPLE_MATHML_CREATE(mtext_, NS_NewMathMLTokenFrame), + SIMPLE_MATHML_CREATE(mo_, NS_NewMathMLmoFrame), + SIMPLE_MATHML_CREATE(mfrac_, NS_NewMathMLmfracFrame), + SIMPLE_MATHML_CREATE(msup_, NS_NewMathMLmmultiscriptsFrame), + SIMPLE_MATHML_CREATE(msub_, NS_NewMathMLmmultiscriptsFrame), + SIMPLE_MATHML_CREATE(msubsup_, NS_NewMathMLmmultiscriptsFrame), + SIMPLE_MATHML_CREATE(munder_, NS_NewMathMLmunderoverFrame), + SIMPLE_MATHML_CREATE(mover_, NS_NewMathMLmunderoverFrame), + SIMPLE_MATHML_CREATE(munderover_, NS_NewMathMLmunderoverFrame), + SIMPLE_MATHML_CREATE(mphantom_, NS_NewMathMLmphantomFrame), + SIMPLE_MATHML_CREATE(mpadded_, NS_NewMathMLmpaddedFrame), + SIMPLE_MATHML_CREATE(mspace_, NS_NewMathMLmspaceFrame), + SIMPLE_MATHML_CREATE(none, NS_NewMathMLmspaceFrame), + SIMPLE_MATHML_CREATE(mprescripts_, NS_NewMathMLmspaceFrame), + SIMPLE_MATHML_CREATE(mfenced_, NS_NewMathMLmfencedFrame), + SIMPLE_MATHML_CREATE(mmultiscripts_, NS_NewMathMLmmultiscriptsFrame), + SIMPLE_MATHML_CREATE(mstyle_, NS_NewMathMLmrowFrame), + SIMPLE_MATHML_CREATE(msqrt_, NS_NewMathMLmsqrtFrame), + SIMPLE_MATHML_CREATE(mroot_, NS_NewMathMLmrootFrame), + SIMPLE_MATHML_CREATE(maction_, NS_NewMathMLmactionFrame), + SIMPLE_MATHML_CREATE(mrow_, NS_NewMathMLmrowFrame), + SIMPLE_MATHML_CREATE(merror_, NS_NewMathMLmrowFrame), + SIMPLE_MATHML_CREATE(menclose_, NS_NewMathMLmencloseFrame), + SIMPLE_MATHML_CREATE(semantics_, NS_NewMathMLsemanticsFrame) + }; + + return FindDataByTag(aTag, aElement, aStyleContext, sMathMLData, + ArrayLength(sMathMLData)); +} + + +nsIFrame* +nsCSSFrameConstructor::ConstructFrameWithAnonymousChild( + nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems, + FrameCreationFunc aConstructor, + FrameCreationFunc aInnerConstructor, + nsICSSAnonBoxPseudo* aInnerPseudo, + bool aCandidateRootFrame) +{ + nsIContent* const content = aItem.mContent; + nsStyleContext* const styleContext = aItem.mStyleContext; + + // Create the outer frame: + nsIFrame* newFrame = aConstructor(mPresShell, styleContext); + + InitAndRestoreFrame(aState, content, + aCandidateRootFrame ? + aState.GetGeometricParent(styleContext->StyleDisplay(), + aParentFrame) : + aParentFrame, + newFrame); + + // Create the pseudo SC for the anonymous wrapper child as a child of the SC: + nsRefPtr scForAnon; + scForAnon = mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(aInnerPseudo, styleContext); + + // Create the anonymous inner wrapper frame + nsIFrame* innerFrame = aInnerConstructor(mPresShell, scForAnon); + + 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, + aCandidateRootFrame, aCandidateRootFrame); + + if (!mRootElementFrame && aCandidateRootFrame) { + // The frame we're constructing will be the root element frame. + // Set mRootElementFrame before processing children. + mRootElementFrame = newFrame; + } + + nsFrameItems childItems; + + // Process children + NS_ASSERTION(aItem.mAnonChildren.IsEmpty(), + "nsIAnonymousContentCreator::CreateAnonymousContent should not " + "be implemented for frames for which we explicitly create an " + "anonymous child to wrap its child frames"); + 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); + } + + // Set the inner wrapper frame's initial primary list + innerFrame->SetInitialChildList(kPrincipalList, childItems); + + return newFrame; +} + +nsIFrame* +nsCSSFrameConstructor::ConstructOuterSVG(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems) +{ + return ConstructFrameWithAnonymousChild( + aState, aItem, aParentFrame, aDisplay, aFrameItems, + NS_NewSVGOuterSVGFrame, NS_NewSVGOuterSVGAnonChildFrame, + nsCSSAnonBoxes::mozSVGOuterSVGAnonChild, true); +} + +nsIFrame* +nsCSSFrameConstructor::ConstructMarker(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems) +{ + return ConstructFrameWithAnonymousChild( + aState, aItem, aParentFrame, aDisplay, aFrameItems, + NS_NewSVGMarkerFrame, NS_NewSVGMarkerAnonChildFrame, + nsCSSAnonBoxes::mozSVGMarkerAnonChild, false); +} + +// Only outer elements can be floated or positioned. All other SVG +// should be in-flow. +#define SIMPLE_SVG_FCDATA(_func) \ + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | \ + FCDATA_SKIP_ABSPOS_PUSH | \ + FCDATA_DISALLOW_GENERATED_CONTENT, _func) +#define SIMPLE_SVG_CREATE(_tag, _func) \ + { &nsGkAtoms::_tag, SIMPLE_SVG_FCDATA(_func) } + +static bool +IsFilterPrimitiveChildTag(const nsIAtom* aTag) +{ + return aTag == nsGkAtoms::feDistantLight || + aTag == nsGkAtoms::fePointLight || + aTag == nsGkAtoms::feSpotLight || + aTag == nsGkAtoms::feFuncR || + aTag == nsGkAtoms::feFuncG || + aTag == nsGkAtoms::feFuncB || + aTag == nsGkAtoms::feFuncA || + aTag == nsGkAtoms::feMergeNode; +} + +/* static */ +const nsCSSFrameConstructor::FrameConstructionData* +nsCSSFrameConstructor::FindSVGData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsIFrame* aParentFrame, + bool aIsWithinSVGText, + bool aAllowsTextPathChild, + nsStyleContext* aStyleContext) +{ + if (aNameSpaceID != kNameSpaceID_SVG) { + return nullptr; + } + + static const FrameConstructionData sSuppressData = SUPPRESS_FCDATA(); + static const FrameConstructionData sContainerData = + SIMPLE_SVG_FCDATA(NS_NewSVGContainerFrame); + + bool parentIsSVG = aIsWithinSVGText; + nsIContent* parentContent = + aParentFrame ? aParentFrame->GetContent() : nullptr; + // XXXbz should this really be based on the XBL-resolved tag of the parent + // frame's content? Should it not be based on the type of the parent frame + // (e.g. whether it's an SVG frame)? + if (parentContent) { + int32_t parentNSID; + nsIAtom* parentTag = + parentContent->OwnerDoc()->BindingManager()-> + ResolveTag(parentContent, &parentNSID); + + // It's not clear whether the SVG spec intends to allow any SVG + // content within svg:foreignObject at all (SVG 1.1, section + // 23.2), but if it does, it better be svg:svg. So given that + // we're allowing it, treat it as a non-SVG parent. + parentIsSVG = parentNSID == kNameSpaceID_SVG && + parentTag != nsGkAtoms::foreignObject; + } + + if ((aTag != nsGkAtoms::svg && !parentIsSVG) || + (aTag == nsGkAtoms::desc || aTag == nsGkAtoms::title)) { + // Sections 5.1 and G.4 of SVG 1.1 say that SVG elements other than + // svg:svg not contained within svg:svg are incorrect, although they + // don't seem to specify error handling. Ignore them, since many of + // our frame classes can't deal. It *may* be that the document + // should at that point be considered in error according to F.2, but + // it's hard to tell. + // + // Style mutation can't change this situation, so don't bother + // adding to the undisplayed content map. + // + // We don't currently handle any UI for desc/title + return &sSuppressData; + } + + // We don't need frames for animation elements + if (aElement->IsNodeOfType(nsINode::eANIMATION)) { + return &sSuppressData; + } + + if (aTag == nsGkAtoms::svg && !parentIsSVG) { + // We need outer elements to have an nsSVGOuterSVGFrame regardless + // of whether they fail conditional processing attributes, since various + // SVG frames assume that one exists. We handle the non-rendering + // of failing outer element contents like statements, + // and do the PassesConditionalProcessingTests call in + // nsSVGOuterSVGFrame::Init. + static const FrameConstructionData sOuterSVGData = + FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructOuterSVG); + return &sOuterSVGData; + } + + if (aTag == nsGkAtoms::marker) { + static const FrameConstructionData sMarkerSVGData = + FULL_CTOR_FCDATA(0, &nsCSSFrameConstructor::ConstructMarker); + return &sMarkerSVGData; + } + + nsCOMPtr tests(do_QueryInterface(aElement)); + if (tests && !tests->PassesConditionalProcessingTests()) { + // Elements with failing conditional processing attributes never get + // rendered. Note that this is not where we select which frame in a + // to render! That happens in nsSVGSwitchFrame::PaintSVG. + return &sContainerData; + } + + // Prevent bad frame types being children of filters or parents of filter + // primitives. If aParentFrame is null, we know that the frame that will + // be created will be an nsInlineFrame, so it can never be a filter. + bool parentIsFilter = aParentFrame && + aParentFrame->GetType() == nsGkAtoms::svgFilterFrame; + bool filterPrimitive = aElement->IsNodeOfType(nsINode::eFILTER); + if ((parentIsFilter && !filterPrimitive) || + (!parentIsFilter && filterPrimitive)) { + return &sSuppressData; + } + + // Prevent bad frame types being children of filter primitives or parents of + // filter primitive children. If aParentFrame is null, we know that the frame + // that will be created will be an nsInlineFrame, so it can never be a filter + // primitive. + bool parentIsFEContainerFrame = aParentFrame && + aParentFrame->GetType() == nsGkAtoms::svgFEContainerFrame; + if ((parentIsFEContainerFrame && !IsFilterPrimitiveChildTag(aTag)) || + (!parentIsFEContainerFrame && IsFilterPrimitiveChildTag(aTag))) { + return &sSuppressData; + } + + // Special cases for text/tspan/textPath, because the kind of frame + // they get depends on the parent frame. We ignore 'a' elements when + // determining the parent, however. + if (aIsWithinSVGText) { + // If aIsWithinSVGText is true, then we know that the "SVG text uses + // CSS frames" pref was true when this SVG fragment was first constructed. + + // We don't use ConstructInline because we want different behavior + // for generated content. + static const FrameConstructionData sTSpanData = + FCDATA_DECL(FCDATA_DISALLOW_OUT_OF_FLOW | + FCDATA_SKIP_ABSPOS_PUSH | + FCDATA_DISALLOW_GENERATED_CONTENT | + FCDATA_IS_LINE_PARTICIPANT | + FCDATA_IS_INLINE | + FCDATA_USE_CHILD_ITEMS, + NS_NewInlineFrame); + if (aTag == nsGkAtoms::textPath) { + if (aAllowsTextPathChild) { + return &sTSpanData; + } + } else if (aTag == nsGkAtoms::tspan || + aTag == nsGkAtoms::altGlyph || + aTag == nsGkAtoms::a) { + return &sTSpanData; + } + return &sSuppressData; + } else if (aTag == nsGkAtoms::text) { + static const FrameConstructionData sTextData = + FCDATA_WITH_WRAPPING_BLOCK(FCDATA_DISALLOW_OUT_OF_FLOW | + FCDATA_ALLOW_BLOCK_STYLES, + NS_NewSVGTextFrame, + nsCSSAnonBoxes::mozSVGText); + return &sTextData; + } else if (aTag == nsGkAtoms::tspan || + aTag == nsGkAtoms::altGlyph || + aTag == nsGkAtoms::textPath) { + return &sSuppressData; + } + + static const FrameConstructionDataByTag sSVGData[] = { + SIMPLE_SVG_CREATE(svg, NS_NewSVGInnerSVGFrame), + SIMPLE_SVG_CREATE(g, NS_NewSVGGFrame), + SIMPLE_SVG_CREATE(svgSwitch, NS_NewSVGSwitchFrame), + SIMPLE_SVG_CREATE(polygon, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(polyline, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(circle, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(ellipse, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(line, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(rect, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(path, NS_NewSVGPathGeometryFrame), + SIMPLE_SVG_CREATE(defs, NS_NewSVGContainerFrame), + SIMPLE_SVG_CREATE(generic_, NS_NewSVGGenericContainerFrame), + { &nsGkAtoms::foreignObject, + FCDATA_WITH_WRAPPING_BLOCK(FCDATA_DISALLOW_OUT_OF_FLOW, + NS_NewSVGForeignObjectFrame, + nsCSSAnonBoxes::mozSVGForeignContent) }, + SIMPLE_SVG_CREATE(a, NS_NewSVGAFrame), + SIMPLE_SVG_CREATE(linearGradient, NS_NewSVGLinearGradientFrame), + SIMPLE_SVG_CREATE(radialGradient, NS_NewSVGRadialGradientFrame), + SIMPLE_SVG_CREATE(stop, NS_NewSVGStopFrame), + SIMPLE_SVG_CREATE(use, NS_NewSVGUseFrame), + SIMPLE_SVG_CREATE(view, NS_NewSVGViewFrame), + SIMPLE_SVG_CREATE(image, NS_NewSVGImageFrame), + SIMPLE_SVG_CREATE(clipPath, NS_NewSVGClipPathFrame), + SIMPLE_SVG_CREATE(filter, NS_NewSVGFilterFrame), + SIMPLE_SVG_CREATE(pattern, NS_NewSVGPatternFrame), + SIMPLE_SVG_CREATE(mask, NS_NewSVGMaskFrame), + SIMPLE_SVG_CREATE(feDistantLight, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(fePointLight, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feSpotLight, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feBlend, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feColorMatrix, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feFuncR, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feFuncG, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feFuncB, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feFuncA, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feComposite, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feComponentTransfer, NS_NewSVGFEContainerFrame), + SIMPLE_SVG_CREATE(feConvolveMatrix, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feDiffuseLighting, NS_NewSVGFEContainerFrame), + SIMPLE_SVG_CREATE(feDisplacementMap, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feDropShadow, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feFlood, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feGaussianBlur, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feImage, NS_NewSVGFEImageFrame), + SIMPLE_SVG_CREATE(feMerge, NS_NewSVGFEContainerFrame), + SIMPLE_SVG_CREATE(feMergeNode, NS_NewSVGFEUnstyledLeafFrame), + SIMPLE_SVG_CREATE(feMorphology, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feOffset, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feSpecularLighting, NS_NewSVGFEContainerFrame), + SIMPLE_SVG_CREATE(feTile, NS_NewSVGFELeafFrame), + SIMPLE_SVG_CREATE(feTurbulence, NS_NewSVGFELeafFrame) + }; + + const FrameConstructionData* data = + FindDataByTag(aTag, aElement, aStyleContext, sSVGData, + ArrayLength(sSVGData)); + + if (!data) { + data = &sContainerData; + } + + return data; +} + +void +nsCSSFrameConstructor::AddPageBreakItem(nsIContent* aContent, + nsStyleContext* aMainStyleContext, + FrameConstructionItemList& aItems) +{ + // Use the same parent style context that |aMainStyleContext| has, since + // that's easier to re-resolve and it doesn't matter in practice. + // (Getting different parents can result in framechange hints, e.g., + // for user-modify.) + nsRefPtr pseudoStyle = + mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(nsCSSAnonBoxes::pageBreak, + aMainStyleContext->GetParent()); + + NS_ASSERTION(pseudoStyle->StyleDisplay()->mDisplay == + NS_STYLE_DISPLAY_BLOCK, "Unexpected display"); + + static const FrameConstructionData sPageBreakData = + FCDATA_DECL(FCDATA_SKIP_FRAMESET, NS_NewPageBreakFrame); + + // Lie about the tag and namespace so we don't trigger anything + // interesting during frame construction. + aItems.AppendItem(&sPageBreakData, aContent, nsCSSAnonBoxes::pageBreak, + kNameSpaceID_None, nullptr, pseudoStyle.forget(), + true, nullptr); +} + +void +nsCSSFrameConstructor::AddFrameConstructionItems(nsFrameConstructorState& aState, + nsIContent* aContent, + bool aSuppressWhiteSpaceOptimizations, + nsIFrame* aParentFrame, + FrameConstructionItemList& aItems) +{ + aContent->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME); + if (aContent->IsElement()) { + // We can't just remove our pending restyle flags, since we may + // have restyle-later-siblings set on us. But we _can_ remove the + // "is possible restyle root" flags, and need to. Otherwise we can + // end up with stale such flags (e.g. if we used to have a + // display:none parent when our last restyle was posted and + // processed and now no longer do). + aContent->UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS & + ~ELEMENT_PENDING_RESTYLE_FLAGS); + } + + // XXX the GetContent() != aContent check is needed due to bug 135040. + // Remove it once that's fixed. + if (aContent->GetPrimaryFrame() && + aContent->GetPrimaryFrame()->GetContent() == aContent && + !aState.mCreatingExtraFrames) { + NS_ERROR("asked to create frame construction item for a node that already " + "has a frame"); + return; + } + + // don't create a whitespace frame if aParent doesn't want it + if (!NeedFrameFor(aState, aParentFrame, aContent)) { + return; + } + + // never create frames for comments or PIs + if (aContent->IsNodeOfType(nsINode::eCOMMENT) || + aContent->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION)) + return; + + nsRefPtr styleContext; + styleContext = ResolveStyleContext(aParentFrame, aContent, &aState); + + uint32_t flags = ITEM_ALLOW_XBL_BASE | ITEM_ALLOW_PAGE_BREAK; + if (aParentFrame->IsSVGText()) { + flags |= ITEM_IS_WITHIN_SVG_TEXT; + } + if (aParentFrame->GetType() == nsGkAtoms::blockFrame && + aParentFrame->GetParent() && + aParentFrame->GetParent()->GetType() == nsGkAtoms::svgTextFrame) { + flags |= ITEM_ALLOWS_TEXT_PATH_CHILD; + } + AddFrameConstructionItemsInternal(aState, aContent, aParentFrame, + aContent->Tag(), aContent->GetNameSpaceID(), + aSuppressWhiteSpaceOptimizations, + styleContext, + flags, nullptr, + aItems); +} + +/* static */ void +nsCSSFrameConstructor::SetAsUndisplayedContent(FrameConstructionItemList& aList, + nsIContent* aContent, + nsStyleContext* aStyleContext, + bool aIsGeneratedContent) +{ + if (aStyleContext->GetPseudo()) { + if (aIsGeneratedContent) { + aContent->UnbindFromTree(); + } + return; + } + + NS_ASSERTION(!aIsGeneratedContent, "Should have had pseudo type"); + aList.AppendUndisplayedItem(aContent, aStyleContext); +} + +void +nsCSSFrameConstructor::AddFrameConstructionItemsInternal(nsFrameConstructorState& aState, + nsIContent* aContent, + nsIFrame* aParentFrame, + nsIAtom* aTag, + int32_t aNameSpaceID, + bool aSuppressWhiteSpaceOptimizations, + nsStyleContext* aStyleContext, + uint32_t aFlags, + nsTArray* aAnonChildren, + FrameConstructionItemList& aItems) +{ + NS_PRECONDITION(aContent->IsNodeOfType(nsINode::eTEXT) || + aContent->IsElement(), + "Shouldn't get anything else here!"); + + // The following code allows the user to specify the base tag + // of an element using XBL. XUL and HTML objects (like boxes, menus, etc.) + // can then be extended arbitrarily. + const nsStyleDisplay* display = aStyleContext->StyleDisplay(); + nsRefPtr styleContext(aStyleContext); + PendingBinding* pendingBinding = nullptr; + if ((aFlags & ITEM_ALLOW_XBL_BASE) && display->mBinding) + { + // Ensure that our XBL bindings are installed. + + nsXBLService* xblService = nsXBLService::GetInstance(); + if (!xblService) + return; + + bool resolveStyle; + + nsAutoPtr newPendingBinding(new PendingBinding()); + + nsresult rv = xblService->LoadBindings(aContent, display->mBinding->GetURI(), + display->mBinding->mOriginPrincipal, + getter_AddRefs(newPendingBinding->mBinding), + &resolveStyle); + if (NS_FAILED(rv) && rv != NS_ERROR_XBL_BLOCKED) + return; + + if (newPendingBinding->mBinding) { + pendingBinding = newPendingBinding; + // aState takes over owning newPendingBinding + aState.AddPendingBinding(newPendingBinding.forget()); + } + + if (resolveStyle) { + styleContext = + ResolveStyleContext(styleContext->GetParent(), aContent, &aState); + display = styleContext->StyleDisplay(); + aStyleContext = styleContext; + } + + aTag = mDocument->BindingManager()->ResolveTag(aContent, &aNameSpaceID); + } + + bool isGeneratedContent = ((aFlags & ITEM_IS_GENERATED_CONTENT) != 0); + + // Pre-check for display "none" - if we find that, don't create + // any frame at all + if (NS_STYLE_DISPLAY_NONE == display->mDisplay) { + SetAsUndisplayedContent(aItems, aContent, styleContext, isGeneratedContent); + return; + } + + bool isText = !aContent->IsElement(); + + // never create frames for non-option/optgroup kids of
so no need to check it + items.SetLineBoundaryAtEnd(!parentAfterFrame || + !parentAfterFrame->IsInlineOutside()); + } + // To suppress whitespace-only text frames, we have to verify that + // our container's DOM child list matches its flattened tree child list. + items.SetParentHasNoXBLChildren(haveNoXBLChildren); + + nsFrameItems frameItems; + ConstructFramesFromItemList(state, items, parentFrame, frameItems); + + for (nsIContent* child = aFirstNewContent; + child; + child = child->GetNextSibling()) { + // Invalidate now instead of before the WipeContainingBlock call, just in + // case we do wipe; in that case we don't need to do this walk at all. + // XXXbz does that matter? Would it make more sense to save some virtual + // GetChildAt calls instead and do this during construction of our + // FrameConstructionItemList? + InvalidateCanvasIfNeeded(mPresShell, child); + } + + // if the container is a table and a caption was appended, it needs to be put + // in the outer table frame's additional child list. + nsFrameItems captionItems; + if (nsGkAtoms::tableFrame == frameType) { + // Pull out the captions. Note that we don't want to do that as we go, + // because processing a single caption can add a whole bunch of things to + // the frame items due to pseudoframe processing. So we'd have to pull + // captions from a list anyway; might as well do that here. + // XXXbz this is no longer true; we could pull captions directly out of the + // FrameConstructionItemList now. + PullOutCaptionFrames(frameItems, captionItems); + } + + if (haveFirstLineStyle && parentFrame == containingBlock) { + // It's possible that some of the new frames go into a + // first-line frame. Look at them and see... + AppendFirstLineFrames(state, containingBlock->GetContent(), + containingBlock, frameItems); + } + + // Notify the parent frame passing it the list of new frames + // Append the flowed frames to the principal child list; captions + // need special treatment + if (captionItems.NotEmpty()) { // append the caption to the outer table + NS_ASSERTION(nsGkAtoms::tableFrame == frameType, "how did that happen?"); + nsIFrame* outerTable = parentFrame->GetParent(); + AppendFrames(outerTable, nsIFrame::kCaptionList, captionItems); + } + + if (frameItems.NotEmpty()) { // append the in-flow kids + AppendFramesToParent(state, parentFrame, frameItems, prevSibling); + } + + // Recover first-letter frames + if (haveFirstLetterStyle) { + RecoverLetterFrames(containingBlock); + } + +#ifdef DEBUG + if (gReallyNoisyContentUpdates) { + printf("nsCSSFrameConstructor::ContentAppended: resulting frame model:\n"); + parentFrame->List(stdout, 0); + } +#endif + +#ifdef ACCESSIBILITY + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + accService->ContentRangeInserted(mPresShell, aContainer, + aFirstNewContent, nullptr); + } +#endif + + return NS_OK; +} + +#ifdef MOZ_XUL + +enum content_operation +{ + CONTENT_INSERTED, + CONTENT_REMOVED +}; + +// Helper function to lookup the listbox body frame and send a notification +// for insertion or removal of content +static +bool NotifyListBoxBody(nsPresContext* aPresContext, + nsIContent* aContainer, + nsIContent* aChild, + // Only used for the removed notification + nsIContent* aOldNextSibling, + nsIDocument* aDocument, + nsIFrame* aChildFrame, + content_operation aOperation) +{ + nsListBoxBodyFrame* listBoxBodyFrame = + MaybeGetListBoxBodyFrame(aContainer, aChild); + if (listBoxBodyFrame) { + if (aOperation == CONTENT_REMOVED) { + // Except if we have an aChildFrame and its parent is not the right + // thing, then we don't do this. Pseudo frames are so much fun.... + if (!aChildFrame || aChildFrame->GetParent() == listBoxBodyFrame) { + listBoxBodyFrame->OnContentRemoved(aPresContext, aContainer, + aChildFrame, aOldNextSibling); + return true; + } + } else { + listBoxBodyFrame->OnContentInserted(aPresContext, aChild); + return true; + } + } + + return false; +} +#endif // MOZ_XUL + +nsresult +nsCSSFrameConstructor::ContentInserted(nsIContent* aContainer, + nsIContent* aChild, + nsILayoutHistoryState* aFrameState, + bool aAllowLazyConstruction) +{ + return ContentRangeInserted(aContainer, + aChild, + aChild->GetNextSibling(), + aFrameState, + aAllowLazyConstruction); +} + +// ContentRangeInserted handles creating frames for a range of nodes that +// aren't at the end of their childlist. ContentRangeInserted isn't a real +// content notification, but rather it handles regular ContentInserted calls +// for a single node as well as the lazy construction of frames for a range of +// nodes when called from CreateNeededFrames. For a range of nodes to be +// suitable to have its frames constructed all at once they must meet the same +// conditions that ContentAppended imposes (GetRangeInsertionPoint checks +// these), plus more. Namely when finding the insertion prevsibling we must not +// need to consult something specific to any one node in the range, so that the +// insertion prevsibling would be the same for each node in the range. So we +// pass the first node in the range to GetInsertionPrevSibling, and if +// IsValidSibling (the only place GetInsertionPrevSibling might look at the +// passed in node itself) needs to resolve style on the node we record this and +// return that this range needs to be split up and inserted separately. Table +// captions need extra attention as we need to determine where to insert them +// in the caption list, while skipping any nodes in the range being inserted +// (because when we treat the caption frames the other nodes have had their +// frames constructed but not yet inserted into the frame tree). +nsresult +nsCSSFrameConstructor::ContentRangeInserted(nsIContent* aContainer, + nsIContent* aStartChild, + nsIContent* aEndChild, + nsILayoutHistoryState* aFrameState, + bool aAllowLazyConstruction) +{ + AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC); + NS_PRECONDITION(mUpdateCount != 0, + "Should be in an update while creating frames"); + + NS_PRECONDITION(aStartChild, "must always pass a child"); + + // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and + // the :empty pseudo-class? +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::ContentRangeInserted container=%p " + "start-child=%p end-child=%p lazy=%d\n", + static_cast(aContainer), + static_cast(aStartChild), static_cast(aEndChild), + aAllowLazyConstruction); + if (gReallyNoisyContentUpdates) { + if (aContainer) { + aContainer->List(stdout,0); + } else { + aStartChild->List(stdout, 0); + } + } + } +#endif + +#ifdef DEBUG + for (nsIContent* child = aStartChild; + child != aEndChild; + child = child->GetNextSibling()) { + // XXX the GetContent() != child check is needed due to bug 135040. + // Remove it once that's fixed. + NS_ASSERTION(!child->GetPrimaryFrame() || + child->GetPrimaryFrame()->GetContent() != child, + "asked to construct a frame for a node that already has a frame"); + } +#endif + + bool isSingleInsert = (aStartChild->GetNextSibling() == aEndChild); + NS_ASSERTION(isSingleInsert || !aAllowLazyConstruction, + "range insert shouldn't be lazy"); + NS_ASSERTION(isSingleInsert || aEndChild, + "range should not include all nodes after aStartChild"); + +#ifdef MOZ_XUL + if (aContainer && IsXULListBox(aContainer)) { + if (isSingleInsert) { + if (NotifyListBoxBody(mPresShell->GetPresContext(), aContainer, + // The insert case in NotifyListBoxBody + // doesn't use "old next sibling". + aStartChild, nullptr, + mDocument, nullptr, CONTENT_INSERTED)) { + return NS_OK; + } + } else { + // We don't handle a range insert to a listbox parent, issue single + // ContertInserted calls for each node inserted. + LAYOUT_PHASE_TEMP_EXIT(); + IssueSingleInsertNofications(aContainer, aStartChild, aEndChild, + aAllowLazyConstruction); + LAYOUT_PHASE_TEMP_REENTER(); + return NS_OK; + } + } +#endif // MOZ_XUL + + // If we have a null parent, then this must be the document element being + // inserted, or some other child of the document in the DOM (might be a PI, + // say). + if (! aContainer) { + NS_ASSERTION(isSingleInsert, + "root node insertion should be a single insertion"); + Element *docElement = mDocument->GetRootElement(); + + if (aStartChild != docElement) { + // Not the root element; just bail out + return NS_OK; + } + + NS_PRECONDITION(nullptr == mRootElementFrame, + "root element frame already created"); + + // Create frames for the document element and its child elements + nsIFrame* docElementFrame = + ConstructDocElementFrame(docElement, aFrameState); + + if (docElementFrame) { + InvalidateCanvasIfNeeded(mPresShell, aStartChild); +#ifdef DEBUG + if (gReallyNoisyContentUpdates) { + printf("nsCSSFrameConstructor::ContentRangeInserted: resulting frame " + "model:\n"); + mFixedContainingBlock->List(stdout, 0); + } +#endif + } + + if (aFrameState) { + // Restore frame state for the root scroll frame if there is one + nsIFrame* rootScrollFrame = mPresShell->GetRootScrollFrame(); + if (rootScrollFrame) { + RestoreFrameStateFor(rootScrollFrame, aFrameState); + } + } + +#ifdef ACCESSIBILITY + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + accService->ContentRangeInserted(mPresShell, aContainer, + aStartChild, aEndChild); + } +#endif + + return NS_OK; + } + + if (aContainer->HasFlag(NODE_IS_IN_SHADOW_TREE)) { + // Recreate frames if content is inserted into a ShadowRoot + // because children of ShadowRoot are rendered in place of + // the children of the host. + nsIContent* bindingParent = aContainer->GetBindingParent(); + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(bindingParent, false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + nsIFrame* parentFrame = GetFrameFor(aContainer); + // The xbl:children element won't have a frame, but default content can have the children as + // a parent. While its uncommon to change the structure of the default content itself, a label, + // for example, can be reframed by having its value attribute set or removed. + if (!parentFrame && !aContainer->IsActiveChildrenElement()) { + return NS_OK; + } + + // Otherwise, we've got parent content. Find its frame. + NS_ASSERTION(!parentFrame || parentFrame->GetContent() == aContainer, "New XBL code is possibly wrong!"); + + if (aAllowLazyConstruction && + MaybeConstructLazily(CONTENTINSERT, aContainer, aStartChild)) { + return NS_OK; + } + + if (isSingleInsert) { + // See if we have an XBL insertion point. If so, then that's our + // real parent frame; if not, then the frame hasn't been built yet + // and we just bail. + parentFrame = GetInsertionPoint(aContainer, aStartChild); + } else { + // Get our insertion point. If we need to issue single ContentInserted's + // GetRangeInsertionPoint will take care of that for us. + LAYOUT_PHASE_TEMP_EXIT(); + parentFrame = GetRangeInsertionPoint(aContainer, aStartChild, aEndChild, + aAllowLazyConstruction); + LAYOUT_PHASE_TEMP_REENTER(); + } + + if (!parentFrame) { + return NS_OK; + } + + bool isAppend, isRangeInsertSafe; + nsIFrame* prevSibling = + GetInsertionPrevSibling(parentFrame, aContainer, aStartChild, + &isAppend, &isRangeInsertSafe); + + // check if range insert is safe + if (!isSingleInsert && !isRangeInsertSafe) { + // must fall back to a single ContertInserted for each child in the range + LAYOUT_PHASE_TEMP_EXIT(); + IssueSingleInsertNofications(aContainer, aStartChild, aEndChild, + aAllowLazyConstruction); + LAYOUT_PHASE_TEMP_REENTER(); + return NS_OK; + } + + nsIContent* container = parentFrame->GetContent(); + + nsIAtom* frameType = parentFrame->GetType(); + LAYOUT_PHASE_TEMP_EXIT(); + if (MaybeRecreateForFrameset(parentFrame, aStartChild, aEndChild)) { + LAYOUT_PHASE_TEMP_REENTER(); + return NS_OK; + } + LAYOUT_PHASE_TEMP_REENTER(); + + // We should only get here with fieldsets when doing a single insert, because + // fieldsets have multiple insertion points. + NS_ASSERTION(isSingleInsert || frameType != nsGkAtoms::fieldSetFrame, + "Unexpected parent"); + if (IsFrameForFieldSet(parentFrame, frameType) && + aStartChild->Tag() == nsGkAtoms::legend) { + // Just reframe the parent, since figuring out whether this + // should be the new legend and then handling it is too complex. + // We could do a little better here --- check if the fieldset already + // has a legend which occurs earlier in its child list than this node, + // and if so, proceed. But we'd have to extend nsFieldSetFrame + // to locate this legend in the inserted frames and extract it. + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(parentFrame->GetContent(), false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + // Don't construct kids of leaves + if (parentFrame->IsLeaf()) { + // Clear lazy bits so we don't try to construct again. + ClearLazyBits(aStartChild, aEndChild); + return NS_OK; + } + + if (parentFrame->IsFrameOfType(nsIFrame::eMathML)) { + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(parentFrame->GetContent(), false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + nsFrameConstructorState state(mPresShell, + GetAbsoluteContainingBlock(parentFrame, FIXED_POS), + GetAbsoluteContainingBlock(parentFrame, ABS_POS), + GetFloatContainingBlock(parentFrame), + aFrameState); + state.mTreeMatchContext.InitAncestors(aContainer ? + aContainer->AsElement() : + nullptr); + + // Recover state for the containing block - we need to know if + // it has :first-letter or :first-line style applied to it. The + // reason we care is that the internal structure in these cases + // is not the normal structure and requires custom updating + // logic. + nsIFrame* containingBlock = state.mFloatedItems.containingBlock; + bool haveFirstLetterStyle = false; + bool haveFirstLineStyle = false; + + // In order to shave off some cycles, we only dig up the + // containing block haveFirst* flags if the parent frame where + // the insertion/append is occurring is an inline or block + // container. For other types of containers this isn't relevant. + uint8_t parentDisplay = parentFrame->GetDisplay(); + + // Examine the parentFrame where the insertion is taking + // place. If it's a certain kind of container then some special + // processing is done. + if ((NS_STYLE_DISPLAY_BLOCK == parentDisplay) || + (NS_STYLE_DISPLAY_LIST_ITEM == parentDisplay) || + (NS_STYLE_DISPLAY_INLINE == parentDisplay) || + (NS_STYLE_DISPLAY_INLINE_BLOCK == parentDisplay)) { + // Recover the special style flags for the containing block + if (containingBlock) { + haveFirstLetterStyle = HasFirstLetterStyle(containingBlock); + haveFirstLineStyle = + ShouldHaveFirstLineStyle(containingBlock->GetContent(), + containingBlock->StyleContext()); + } + + if (haveFirstLetterStyle) { + // If our current parentFrame is a Letter frame, use its parent as our + // new parent hint + if (parentFrame->GetType() == nsGkAtoms::letterFrame) { + // If parentFrame is out of flow, then we actually want the parent of + // the placeholder frame. + if (parentFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) { + nsPlaceholderFrame* placeholderFrame = + GetPlaceholderFrameFor(parentFrame); + NS_ASSERTION(placeholderFrame, "No placeholder for out-of-flow?"); + parentFrame = placeholderFrame->GetParent(); + } else { + parentFrame = parentFrame->GetParent(); + } + } + + // Remove the old letter frames before doing the insertion + RemoveLetterFrames(state.mPresContext, mPresShell, + state.mFloatedItems.containingBlock); + + // Removing the letterframes messes around with the frame tree, removing + // and creating frames. We need to reget our prevsibling, parent frame, + // etc. + prevSibling = GetInsertionPrevSibling(parentFrame, aContainer, + aStartChild, &isAppend, + &isRangeInsertSafe); + + // Need check whether a range insert is still safe. + if (!isSingleInsert && !isRangeInsertSafe) { + // Need to recover the letter frames first. + RecoverLetterFrames(state.mFloatedItems.containingBlock); + + // must fall back to a single ContertInserted for each child in the range + LAYOUT_PHASE_TEMP_EXIT(); + IssueSingleInsertNofications(aContainer, aStartChild, aEndChild, + aAllowLazyConstruction); + LAYOUT_PHASE_TEMP_REENTER(); + return NS_OK; + } + + container = parentFrame->GetContent(); + frameType = parentFrame->GetType(); + } + } + + if (!prevSibling) { + // We're inserting the new frames as the first child. See if the + // parent has a :before pseudo-element + nsIFrame* firstChild = parentFrame->GetFirstPrincipalChild(); + + if (firstChild && + nsLayoutUtils::IsGeneratedContentFor(container, firstChild, + nsCSSPseudoElements::before)) { + // Insert the new frames after the last continuation of the :before + prevSibling = firstChild->GetTailContinuation(); + parentFrame = prevSibling->GetParent()->GetContentInsertionFrame(); + // Don't change isAppend here; we'll can call AppendFrames as needed, and + // the change to our prevSibling doesn't affect that. + } + } + + FrameConstructionItemList items; + ParentType parentType = GetParentType(frameType); + FlattenedChildIterator iter(aContainer); + bool haveNoXBLChildren = (!iter.XBLInvolved() || !iter.GetNextChild()); + if (aStartChild->GetPreviousSibling() && + parentType == eTypeBlock && haveNoXBLChildren) { + // If there's a text node in the normal content list just before the + // new nodes, and it has no frame, make a frame construction item for + // it, because it might need a frame now. No need to do this if our + // parent type is not block, though, since WipeContainingBlock + // already handles that sitation. + AddTextItemIfNeeded(state, parentFrame, aStartChild->GetPreviousSibling(), + items); + } + + if (isSingleInsert) { + AddFrameConstructionItems(state, aStartChild, + aStartChild->IsRootOfAnonymousSubtree(), + parentFrame, items); + } else { + for (nsIContent* child = aStartChild; + child != aEndChild; + child = child->GetNextSibling()){ + AddFrameConstructionItems(state, child, false, parentFrame, items); + } + } + + if (aEndChild && parentType == eTypeBlock && haveNoXBLChildren) { + // If there's a text node in the normal content list just after the + // new nodes, and it has no frame, make a frame construction item for + // it, because it might need a frame now. No need to do this if our + // parent type is not block, though, since WipeContainingBlock + // already handles that sitation. + AddTextItemIfNeeded(state, parentFrame, aEndChild, items); + } + + // Perform special check for diddling around with the frames in + // a special inline frame. + // If we're appending before :after content, then we're not really + // appending, so let WipeContainingBlock know that. + LAYOUT_PHASE_TEMP_EXIT(); + if (WipeContainingBlock(state, containingBlock, parentFrame, items, + isAppend, prevSibling)) { + LAYOUT_PHASE_TEMP_REENTER(); + return NS_OK; + } + LAYOUT_PHASE_TEMP_REENTER(); + + // If the container is a table and a caption will be appended, it needs to be + // put in the outer table frame's additional child list. + // We make no attempt here to set flags to indicate whether the list + // will be at the start or end of a block. It doesn't seem worthwhile. + nsFrameItems frameItems, captionItems; + ConstructFramesFromItemList(state, items, parentFrame, frameItems); + + if (frameItems.NotEmpty()) { + for (nsIContent* child = aStartChild; + child != aEndChild; + child = child->GetNextSibling()){ + InvalidateCanvasIfNeeded(mPresShell, child); + } + + if (nsGkAtoms::tableFrame == frameType || + nsGkAtoms::tableOuterFrame == frameType) { + PullOutCaptionFrames(frameItems, captionItems); + } + } + + // If the parent of our current prevSibling is different from the frame we'll + // actually use as the parent, then the calculated insertion point is now + // invalid and as it is unknown where to insert correctly we append instead + // (bug 341858). + // This can affect our prevSibling and isAppend, but should not have any + // effect on the WipeContainingBlock above, since this should only happen + // when neither parent is a ib-split frame and should not affect whitespace + // handling inside table-related frames (and in fact, can only happen when + // one of the parents is an outer table and one is an inner table or when the + // parent is a fieldset or fieldset content frame). So it won't affect the + // {ib} or XUL box cases in WipeContainingBlock(), and the table pseudo + // handling will only be affected by us maybe thinking we're not inserting + // at the beginning, whereas we really are. That would have made us reframe + // unnecessarily, but that's ok. + // XXXbz we should push our frame construction item code up higher, so we + // know what our items are by the time we start figuring out previous + // siblings + if (prevSibling && frameItems.NotEmpty() && + frameItems.FirstChild()->GetParent() != prevSibling->GetParent()) { +#ifdef DEBUG + nsIFrame* frame1 = frameItems.FirstChild()->GetParent(); + nsIFrame* frame2 = prevSibling->GetParent(); + NS_ASSERTION(!IsFramePartOfIBSplit(frame1) && + !IsFramePartOfIBSplit(frame2), + "Neither should be ib-split"); + NS_ASSERTION((frame1->GetType() == nsGkAtoms::tableFrame && + frame2->GetType() == nsGkAtoms::tableOuterFrame) || + (frame1->GetType() == nsGkAtoms::tableOuterFrame && + frame2->GetType() == nsGkAtoms::tableFrame) || + frame1->GetType() == nsGkAtoms::fieldSetFrame || + (frame1->GetParent() && + frame1->GetParent()->GetType() == nsGkAtoms::fieldSetFrame), + "Unexpected frame types"); +#endif + isAppend = true; + nsIFrame* appendAfterFrame; + parentFrame = + ::AdjustAppendParentForAfterContent(mPresShell->GetPresContext(), + container, + frameItems.FirstChild()->GetParent(), + &appendAfterFrame); + prevSibling = ::FindAppendPrevSibling(parentFrame, appendAfterFrame); + } + + if (haveFirstLineStyle && parentFrame == containingBlock) { + // It's possible that the new frame goes into a first-line + // frame. Look at it and see... + if (isAppend) { + // Use append logic when appending + AppendFirstLineFrames(state, containingBlock->GetContent(), + containingBlock, frameItems); + } + else { + // Use more complicated insert logic when inserting + // XXXbz this method is a no-op, so it's easy for the args being passed + // here to make no sense without anyone noticing... If it ever stops + // being a no-op, vet them carefully! + InsertFirstLineFrames(state, container, containingBlock, &parentFrame, + prevSibling, frameItems); + } + } + + // We might have captions; put them into the caption list of the + // outer table frame. + if (captionItems.NotEmpty()) { + NS_ASSERTION(nsGkAtoms::tableFrame == frameType || + nsGkAtoms::tableOuterFrame == frameType, + "parent for caption is not table?"); + // We need to determine where to put the caption items; start with the + // the parent frame that has already been determined and get the insertion + // prevsibling of the first caption item. + nsIFrame* captionParent = parentFrame; + bool captionIsAppend; + nsIFrame* captionPrevSibling = nullptr; + + // aIsRangeInsertSafe is ignored on purpose because it is irrelevant here. + bool ignored; + if (isSingleInsert) { + captionPrevSibling = + GetInsertionPrevSibling(captionParent, aContainer, aStartChild, + &captionIsAppend, &ignored); + } else { + nsIContent* firstCaption = captionItems.FirstChild()->GetContent(); + // It is very important here that we skip the children in + // [aStartChild,aEndChild) when looking for a + // prevsibling. + captionPrevSibling = + GetInsertionPrevSibling(captionParent, aContainer, firstCaption, + &captionIsAppend, &ignored, + aStartChild, aEndChild); + } + + nsIFrame* outerTable = nullptr; + if (GetCaptionAdjustedParent(captionParent, captionItems.FirstChild(), + &outerTable)) { + // If the parent is not an outer table frame we will try to add frames + // to a named child list that the parent does not honour and the frames + // will get lost + NS_ASSERTION(nsGkAtoms::tableOuterFrame == outerTable->GetType(), + "Pseudo frame construction failure; " + "a caption can be only a child of an outer table frame"); + + // If the parent of our current prevSibling is different from the frame + // we'll actually use as the parent, then the calculated insertion + // point is now invalid (bug 341382). + if (captionPrevSibling && + captionPrevSibling->GetParent() != outerTable) { + captionPrevSibling = nullptr; + } + if (captionIsAppend) { + AppendFrames(outerTable, nsIFrame::kCaptionList, captionItems); + } else { + InsertFrames(outerTable, nsIFrame::kCaptionList, + captionPrevSibling, captionItems); + } + } + } + + if (frameItems.NotEmpty()) { + // Notify the parent frame + if (isAppend) { + AppendFramesToParent(state, parentFrame, frameItems, prevSibling); + } else { + InsertFrames(parentFrame, kPrincipalList, prevSibling, frameItems); + } + } + + if (haveFirstLetterStyle) { + // Recover the letter frames for the containing block when + // it has first-letter style. + RecoverLetterFrames(state.mFloatedItems.containingBlock); + } + +#ifdef DEBUG + if (gReallyNoisyContentUpdates && parentFrame) { + printf("nsCSSFrameConstructor::ContentRangeInserted: resulting frame model:\n"); + parentFrame->List(stdout, 0); + } +#endif + +#ifdef ACCESSIBILITY + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + accService->ContentRangeInserted(mPresShell, aContainer, + aStartChild, aEndChild); + } +#endif + + return NS_OK; +} + +nsresult +nsCSSFrameConstructor::ContentRemoved(nsIContent* aContainer, + nsIContent* aChild, + nsIContent* aOldNextSibling, + RemoveFlags aFlags, + bool* aDidReconstruct) +{ + AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC); + NS_PRECONDITION(mUpdateCount != 0, + "Should be in an update while destroying frames"); + + *aDidReconstruct = false; + + // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and + // the :empty pseudo-class? + +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::ContentRemoved container=%p child=%p " + "old-next-sibling=%p\n", + static_cast(aContainer), + static_cast(aChild), + static_cast(aOldNextSibling)); + if (gReallyNoisyContentUpdates) { + aContainer->List(stdout, 0); + } + } +#endif + + nsPresContext *presContext = mPresShell->GetPresContext(); + nsresult rv = NS_OK; + + // Find the child frame that maps the content + nsIFrame* childFrame = aChild->GetPrimaryFrame(); + + if (!childFrame || childFrame->GetContent() != aChild) { + // XXXbz the GetContent() != aChild check is needed due to bug 135040. + // Remove it once that's fixed. + ClearUndisplayedContentIn(aChild, aContainer); + } + +#ifdef MOZ_XUL + if (NotifyListBoxBody(presContext, aContainer, aChild, aOldNextSibling, + mDocument, childFrame, CONTENT_REMOVED)) + return NS_OK; + +#endif // MOZ_XUL + + // If we're removing the root, then make sure to remove things starting at + // the viewport's child instead of the primary frame (which might even be + // null if the root had an XBL binding or display:none, even though the + // frames above it got created). We do the adjustment after the childFrame + // check above, because we do want to clear any undisplayed content we might + // have for the root. Detecting removal of a root is a little exciting; in + // particular, having a null aContainer is necessary but NOT sufficient. Due + // to how we process reframes, the content node might not even be in our + // document by now. So explicitly check whether the viewport's first kid's + // content node is aChild. + bool isRoot = false; + if (!aContainer) { + nsIFrame* viewport = GetRootFrame(); + if (viewport) { + nsIFrame* firstChild = viewport->GetFirstPrincipalChild(); + if (firstChild && firstChild->GetContent() == aChild) { + isRoot = true; + childFrame = firstChild; + NS_ASSERTION(!childFrame->GetNextSibling(), "How did that happen?"); + } + } + } + + if (aContainer && aContainer->HasFlag(NODE_IS_IN_SHADOW_TREE)) { + // Recreate frames if content is removed from a ShadowRoot + // because it may contain an insertion point which can change + // how the host is rendered. + nsIContent* bindingParent = aContainer->GetBindingParent(); + *aDidReconstruct = true; + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(bindingParent, false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + if (childFrame) { + InvalidateCanvasIfNeeded(mPresShell, aChild); + + // See whether we need to remove more than just childFrame + LAYOUT_PHASE_TEMP_EXIT(); + if (MaybeRecreateContainerForFrameRemoval(childFrame, &rv)) { + LAYOUT_PHASE_TEMP_REENTER(); + *aDidReconstruct = true; + return rv; + } + LAYOUT_PHASE_TEMP_REENTER(); + + // Get the childFrame's parent frame + nsIFrame* parentFrame = childFrame->GetParent(); + nsIAtom* parentType = parentFrame->GetType(); + + if (parentType == nsGkAtoms::frameSetFrame && + IsSpecialFramesetChild(aChild)) { + // Just reframe the parent, since framesets are weird like that. + *aDidReconstruct = true; + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(parentFrame->GetContent(), false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + // If we're a child of MathML, then we should reframe the MathML content. + // If we're non-MathML, then we would be wrapped in a block so we need to + // check our grandparent in that case. + nsIFrame* possibleMathMLAncestor = parentType == nsGkAtoms::blockFrame ? + parentFrame->GetParent() : parentFrame; + if (possibleMathMLAncestor->IsFrameOfType(nsIFrame::eMathML)) { + *aDidReconstruct = true; + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(possibleMathMLAncestor->GetContent(), false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + // Undo XUL wrapping if it's no longer needed. + // (If we're in the XUL block-wrapping situation, parentFrame is the + // wrapper frame.) + nsIFrame* grandparentFrame = parentFrame->GetParent(); + if (grandparentFrame && grandparentFrame->IsBoxFrame() && + (grandparentFrame->GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK) && + // check if this frame is the only one needing wrapping + aChild == AnyKidsNeedBlockParent(parentFrame->GetFirstPrincipalChild()) && + !AnyKidsNeedBlockParent(childFrame->GetNextSibling())) { + *aDidReconstruct = true; + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(grandparentFrame->GetContent(), true); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + +#ifdef ACCESSIBILITY + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + accService->ContentRemoved(mPresShell, aContainer, aChild); + } +#endif + + // Examine the containing-block for the removed content and see if + // :first-letter style applies. + nsIFrame* inflowChild = childFrame; + if (childFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) { + inflowChild = GetPlaceholderFrameFor(childFrame); + NS_ASSERTION(inflowChild, "No placeholder for out-of-flow?"); + } + nsIFrame* containingBlock = + GetFloatContainingBlock(inflowChild->GetParent()); + bool haveFLS = containingBlock && HasFirstLetterStyle(containingBlock); + if (haveFLS) { + // Trap out to special routine that handles adjusting a blocks + // frame tree when first-letter style is present. +#ifdef NOISY_FIRST_LETTER + printf("ContentRemoved: containingBlock="); + nsFrame::ListTag(stdout, containingBlock); + printf(" parentFrame="); + nsFrame::ListTag(stdout, parentFrame); + printf(" childFrame="); + nsFrame::ListTag(stdout, childFrame); + printf("\n"); +#endif + + // First update the containing blocks structure by removing the + // existing letter frames. This makes the subsequent logic + // simpler. + RemoveLetterFrames(presContext, mPresShell, containingBlock); + + // Recover childFrame and parentFrame + childFrame = aChild->GetPrimaryFrame(); + if (!childFrame || childFrame->GetContent() != aChild) { + // XXXbz the GetContent() != aChild check is needed due to bug 135040. + // Remove it once that's fixed. + ClearUndisplayedContentIn(aChild, aContainer); + return NS_OK; + } + parentFrame = childFrame->GetParent(); + parentType = parentFrame->GetType(); + +#ifdef NOISY_FIRST_LETTER + printf(" ==> revised parentFrame="); + nsFrame::ListTag(stdout, parentFrame); + printf(" childFrame="); + nsFrame::ListTag(stdout, childFrame); + printf("\n"); +#endif + } + +#ifdef DEBUG + if (gReallyNoisyContentUpdates) { + printf("nsCSSFrameConstructor::ContentRemoved: childFrame="); + nsFrame::ListTag(stdout, childFrame); + putchar('\n'); + parentFrame->List(stdout, 0); + } +#endif + + + // Notify the parent frame that it should delete the frame + if (childFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) { + childFrame = GetPlaceholderFrameFor(childFrame); + NS_ASSERTION(childFrame, "Missing placeholder frame for out of flow."); + parentFrame = childFrame->GetParent(); + } + rv = RemoveFrame(nsLayoutUtils::GetChildListNameFor(childFrame), + childFrame); + //XXXfr NS_ENSURE_SUCCESS(rv, rv) ? + + if (isRoot) { + mRootElementFrame = nullptr; + mRootElementStyleFrame = nullptr; + mDocElementContainingBlock = nullptr; + mPageSequenceFrame = nullptr; + mGfxScrollFrame = nullptr; + mHasRootAbsPosContainingBlock = false; + mFixedContainingBlock = GetRootFrame(); + } + + if (haveFLS && mRootElementFrame) { + RecoverLetterFrames(containingBlock); + } + + // If we're just reconstructing frames for the element, then the + // following ContentInserted notification on the element will + // take care of fixing up any adjacent text nodes. We don't need + // to do this if the table parent type of our parent type is not + // eTypeBlock, though, because in that case the whitespace isn't + // being suppressed due to us anyway. + if (aContainer && !aChild->IsRootOfAnonymousSubtree() && + aFlags != REMOVE_FOR_RECONSTRUCTION && + GetParentType(parentType) == eTypeBlock) { + // Adjacent whitespace-only text nodes might have been suppressed if + // this node does not have inline ends. Create frames for them now + // if necessary. + // Reframe any text node just before the node being removed, if there is + // one, and if it's not the last child or the first child. If a whitespace + // textframe was being suppressed and it's now the last child or first + // child then it can stay suppressed since the parent must be a block + // and hence it's adjacent to a block end. + // If aOldNextSibling is null, then the text node before the node being + // removed is the last node, and we don't need to worry about it. + if (aOldNextSibling) { + nsIContent* prevSibling = aOldNextSibling->GetPreviousSibling(); + if (prevSibling && prevSibling->GetPreviousSibling()) { + LAYOUT_PHASE_TEMP_EXIT(); + ReframeTextIfNeeded(aContainer, prevSibling); + LAYOUT_PHASE_TEMP_REENTER(); + } + } + // Reframe any text node just after the node being removed, if there is + // one, and if it's not the last child or the first child. + if (aOldNextSibling && aOldNextSibling->GetNextSibling() && + aOldNextSibling->GetPreviousSibling()) { + LAYOUT_PHASE_TEMP_EXIT(); + ReframeTextIfNeeded(aContainer, aOldNextSibling); + LAYOUT_PHASE_TEMP_REENTER(); + } + } + +#ifdef DEBUG + if (gReallyNoisyContentUpdates && parentFrame) { + printf("nsCSSFrameConstructor::ContentRemoved: resulting frame model:\n"); + parentFrame->List(stdout, 0); + } +#endif + } + + return rv; +} + +/** + * This method invalidates the canvas when frames are removed or added for a + * node that might have its background propagated to the canvas, i.e., a + * document root node or an HTML BODY which is a child of the root node. + * + * @param aFrame a frame for a content node about to be removed or a frame that + * was just created for a content node that was inserted. + */ +static void +InvalidateCanvasIfNeeded(nsIPresShell* presShell, nsIContent* node) +{ + NS_PRECONDITION(presShell->GetRootFrame(), "What happened here?"); + NS_PRECONDITION(presShell->GetPresContext(), "Say what?"); + + // Note that both in ContentRemoved and ContentInserted the content node + // will still have the right parent pointer, so looking at that is ok. + + nsIContent* parent = node->GetParent(); + if (parent) { + // Has a parent; might not be what we want + nsIContent* grandParent = parent->GetParent(); + if (grandParent) { + // Has a grandparent, so not what we want + return; + } + + // Check whether it's an HTML body + if (node->Tag() != nsGkAtoms::body || + !node->IsHTML()) { + return; + } + } + + // At this point the node has no parent or it's an HTML child of the + // root. We might not need to invalidate in this case (eg we might be in + // XHTML or something), but chances are we want to. Play it safe. + // Invalidate the viewport. + + nsIFrame* rootFrame = presShell->GetRootFrame(); + rootFrame->InvalidateFrameSubtree(); +} + +nsIFrame* +nsCSSFrameConstructor::EnsureFrameForTextNode(nsGenericDOMDataNode* aContent) +{ + if (aContent->HasFlag(NS_CREATE_FRAME_IF_NON_WHITESPACE) && + !mAlwaysCreateFramesForIgnorableWhitespace) { + // Text frame may have been suppressed. Disable suppression and signal + // that a flush should be performed. We do this on a document-wide + // basis so that pages that repeatedly query metrics for + // collapsed-whitespace text nodes don't trigger pathological behavior. + mAlwaysCreateFramesForIgnorableWhitespace = true; + nsAutoScriptBlocker blocker; + BeginUpdate(); + ReconstructDocElementHierarchy(); + EndUpdate(); + } + return aContent->GetPrimaryFrame(); +} + +nsresult +nsCSSFrameConstructor::CharacterDataChanged(nsIContent* aContent, + CharacterDataChangeInfo* aInfo) +{ + AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC); + nsresult rv = NS_OK; + + if ((aContent->HasFlag(NS_CREATE_FRAME_IF_NON_WHITESPACE) && + !aContent->TextIsOnlyWhitespace()) || + (aContent->HasFlag(NS_REFRAME_IF_WHITESPACE) && + aContent->TextIsOnlyWhitespace())) { +#ifdef DEBUG + nsIFrame* frame = aContent->GetPrimaryFrame(); + NS_ASSERTION(!frame || !frame->IsGeneratedContentFrame(), + "Bit should never be set on generated content"); +#endif + LAYOUT_PHASE_TEMP_EXIT(); + nsresult rv = RecreateFramesForContent(aContent, false); + LAYOUT_PHASE_TEMP_REENTER(); + return rv; + } + + // Find the child frame + nsIFrame* frame = aContent->GetPrimaryFrame(); + + // Notify the first frame that maps the content. It will generate a reflow + // command + + // It's possible the frame whose content changed isn't inserted into the + // frame hierarchy yet, or that there is no frame that maps the content + if (nullptr != frame) { +#if 0 + NS_FRAME_LOG(NS_FRAME_TRACE_CALLS, + ("nsCSSFrameConstructor::CharacterDataChanged: content=%p[%s] subcontent=%p frame=%p", + aContent, ContentTag(aContent, 0), + aSubContent, frame)); +#endif + + // Special check for text content that is a child of a letter frame. If + // this happens, we should remove the letter frame, do whatever we're + // planning to do with this notification, then put the letter frame back. + // Note that this is basically what RecreateFramesForContent ends up doing; + // the reason we dont' want to call that here is that our text content + // could be native anonymous, in which case RecreateFramesForContent would + // completely barf on it. And recreating the non-anonymous ancestor would + // just lead us to come back into this notification (e.g. if quotes or + // counters are involved), leading to a loop. + nsIFrame* block = GetFloatContainingBlock(frame); + bool haveFirstLetterStyle = false; + if (block) { + // See if the block has first-letter style applied to it. + haveFirstLetterStyle = HasFirstLetterStyle(block); + if (haveFirstLetterStyle) { + RemoveLetterFrames(mPresShell->GetPresContext(), mPresShell, + block); + // Reget |frame|, since we might have killed it. + // Do we really need to call CharacterDataChanged in this case, though? + frame = aContent->GetPrimaryFrame(); + NS_ASSERTION(frame, "Should have frame here!"); + } + } + + frame->CharacterDataChanged(aInfo); + + if (haveFirstLetterStyle) { + RecoverLetterFrames(block); + } + } + + return rv; +} + +void +nsCSSFrameConstructor::BeginUpdate() { + NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(), + "Someone forgot a script blocker"); + + nsRootPresContext* rootPresContext = + mPresShell->GetPresContext()->GetRootPresContext(); + if (rootPresContext) { + rootPresContext->IncrementDOMGeneration(); + } + + ++sGlobalGenerationNumber; + ++mUpdateCount; +} + +void +nsCSSFrameConstructor::EndUpdate() +{ + if (mUpdateCount == 1) { + // This is the end of our last update. Before we decrement + // mUpdateCount, recalc quotes and counters as needed. + + RecalcQuotesAndCounters(); + NS_ASSERTION(mUpdateCount == 1, "Odd update count"); + } + NS_ASSERTION(mUpdateCount, "Negative mUpdateCount!"); + --mUpdateCount; +} + +void +nsCSSFrameConstructor::RecalcQuotesAndCounters() +{ + if (mQuotesDirty) { + mQuotesDirty = false; + mQuoteList.RecalcAll(); + } + + if (mCountersDirty) { + mCountersDirty = false; + mCounterManager.RecalcAll(); + } + + NS_ASSERTION(!mQuotesDirty, "Quotes updates will be lost"); + NS_ASSERTION(!mCountersDirty, "Counter updates will be lost"); +} + +void +nsCSSFrameConstructor::WillDestroyFrameTree() +{ +#if defined(DEBUG_dbaron_off) + mCounterManager.Dump(); +#endif + + mIsDestroyingFrameTree = true; + + // Prevent frame tree destruction from being O(N^2) + mQuoteList.Clear(); + mCounterManager.Clear(); + + // Remove our presshell as a style flush observer. But leave + // RestyleManager::mObservingRefreshDriver true so we don't readd to + // it even if someone tries to post restyle events on us from this + // point on for some reason. + mPresShell->GetPresContext()->RefreshDriver()-> + RemoveStyleFlushObserver(mPresShell); + + nsFrameManager::Destroy(); +} + +//STATIC + +// XXXbz I'd really like this method to go away. Once we have inline-block and +// I can just use that for sized broken images, that can happen, maybe. +void nsCSSFrameConstructor::GetAlternateTextFor(nsIContent* aContent, + nsIAtom* aTag, // content object's tag + nsXPIDLString& aAltText) +{ + // The "alt" attribute specifies alternate text that is rendered + // when the image can not be displayed + + // If there's no "alt" attribute, and aContent is an input + // element, then use the value of the "value" attribute + if (!aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::alt, aAltText) && + nsGkAtoms::input == aTag) { + // If there's no "value" attribute either, then use the localized string + // for "Submit" as the alternate text. + if (!aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::value, aAltText)) { + nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES, + "Submit", aAltText); + } + } +} + +nsIFrame* +nsCSSFrameConstructor::CreateContinuingOuterTableFrame(nsIPresShell* aPresShell, + nsPresContext* aPresContext, + nsIFrame* aFrame, + nsIFrame* aParentFrame, + nsIContent* aContent, + nsStyleContext* aStyleContext) +{ + nsIFrame* newFrame = NS_NewTableOuterFrame(aPresShell, aStyleContext); + + newFrame->Init(aContent, aParentFrame, aFrame); + + // Create a continuing inner table frame, and if there's a caption then + // replicate the caption + nsFrameItems newChildFrames; + + nsIFrame* childFrame = aFrame->GetFirstPrincipalChild(); + if (childFrame) { + nsIFrame* continuingTableFrame = + CreateContinuingFrame(aPresContext, childFrame, newFrame); + newChildFrames.AddChild(continuingTableFrame); + + NS_ASSERTION(!childFrame->GetNextSibling(),"there can be only one inner table frame"); + } + + // Set the outer table's initial child list + newFrame->SetInitialChildList(kPrincipalList, newChildFrames); + + return newFrame; +} + +nsIFrame* +nsCSSFrameConstructor::CreateContinuingTableFrame(nsIPresShell* aPresShell, + nsPresContext* aPresContext, + nsIFrame* aFrame, + nsIFrame* aParentFrame, + nsIContent* aContent, + nsStyleContext* aStyleContext) +{ + nsIFrame* newFrame = NS_NewTableFrame(aPresShell, aStyleContext); + + newFrame->Init(aContent, aParentFrame, aFrame); + + // Replicate any header/footer frames + nsFrameItems childFrames; + nsIFrame* childFrame = aFrame->GetFirstPrincipalChild(); + for ( ; childFrame; childFrame = childFrame->GetNextSibling()) { + // See if it's a header/footer, possibly wrapped in a scroll frame. + nsTableRowGroupFrame* rowGroupFrame = + static_cast(childFrame); + // If the row group was continued, then don't replicate it. + nsIFrame* rgNextInFlow = rowGroupFrame->GetNextInFlow(); + if (rgNextInFlow) { + rowGroupFrame->SetRepeatable(false); + } + else if (rowGroupFrame->IsRepeatable()) { + // Replicate the header/footer frame. + nsTableRowGroupFrame* headerFooterFrame; + nsFrameItems childItems; + nsFrameConstructorState state(mPresShell, + GetAbsoluteContainingBlock(newFrame, FIXED_POS), + GetAbsoluteContainingBlock(newFrame, ABS_POS), + nullptr); + state.mCreatingExtraFrames = true; + + nsStyleContext* const headerFooterStyleContext = rowGroupFrame->StyleContext(); + headerFooterFrame = static_cast + (NS_NewTableRowGroupFrame(aPresShell, headerFooterStyleContext)); + + nsIContent* headerFooter = rowGroupFrame->GetContent(); + headerFooterFrame->Init(headerFooter, newFrame, nullptr); + + nsFrameConstructorSaveState absoluteSaveState; + MakeTablePartAbsoluteContainingBlockIfNeeded(state, + headerFooterStyleContext->StyleDisplay(), + absoluteSaveState, + headerFooterFrame); + + ProcessChildren(state, headerFooter, rowGroupFrame->StyleContext(), + headerFooterFrame, true, childItems, false, + nullptr); + NS_ASSERTION(state.mFloatedItems.IsEmpty(), "unexpected floated element"); + headerFooterFrame->SetInitialChildList(kPrincipalList, childItems); + headerFooterFrame->SetRepeatable(true); + + // Table specific initialization + headerFooterFrame->InitRepeatedFrame(aPresContext, rowGroupFrame); + + // XXX Deal with absolute and fixed frames... + childFrames.AddChild(headerFooterFrame); + } + } + + // Set the table frame's initial child list + newFrame->SetInitialChildList(kPrincipalList, childFrames); + + return newFrame; +} + +nsIFrame* +nsCSSFrameConstructor::CreateContinuingFrame(nsPresContext* aPresContext, + nsIFrame* aFrame, + nsIFrame* aParentFrame, + bool aIsFluid) +{ + nsIPresShell* shell = aPresContext->PresShell(); + nsStyleContext* styleContext = aFrame->StyleContext(); + nsIFrame* newFrame = nullptr; + nsIFrame* nextContinuation = aFrame->GetNextContinuation(); + nsIFrame* nextInFlow = aFrame->GetNextInFlow(); + + // Use the frame type to determine what type of frame to create + nsIAtom* frameType = aFrame->GetType(); + nsIContent* content = aFrame->GetContent(); + + NS_ASSERTION(aFrame->GetSplittableType() != NS_FRAME_NOT_SPLITTABLE, + "why CreateContinuingFrame for a non-splittable frame?"); + + if (nsGkAtoms::textFrame == frameType) { + newFrame = NS_NewContinuingTextFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::inlineFrame == frameType) { + newFrame = NS_NewInlineFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::blockFrame == frameType) { + newFrame = NS_NewBlockFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); +#ifdef MOZ_XUL + } else if (nsGkAtoms::XULLabelFrame == frameType) { + newFrame = NS_NewXULLabelFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); +#endif + } else if (nsGkAtoms::columnSetFrame == frameType) { + newFrame = NS_NewColumnSetFrame(shell, styleContext, nsFrameState(0)); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::pageFrame == frameType) { + nsIFrame* canvasFrame; + newFrame = ConstructPageFrame(shell, aPresContext, aParentFrame, aFrame, + canvasFrame); + } else if (nsGkAtoms::tableOuterFrame == frameType) { + newFrame = + CreateContinuingOuterTableFrame(shell, aPresContext, aFrame, aParentFrame, + content, styleContext); + + } else if (nsGkAtoms::tableFrame == frameType) { + newFrame = + CreateContinuingTableFrame(shell, aPresContext, aFrame, aParentFrame, + content, styleContext); + + } else if (nsGkAtoms::tableRowGroupFrame == frameType) { + newFrame = NS_NewTableRowGroupFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + if (newFrame->GetStateBits() & NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN) { + nsTableFrame::RegisterPositionedTablePart(newFrame); + } + } else if (nsGkAtoms::tableRowFrame == frameType) { + newFrame = NS_NewTableRowFrame(shell, styleContext); + + newFrame->Init(content, aParentFrame, aFrame); + if (newFrame->GetStateBits() & NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN) { + nsTableFrame::RegisterPositionedTablePart(newFrame); + } + + // Create a continuing frame for each table cell frame + nsFrameItems newChildList; + nsIFrame* cellFrame = aFrame->GetFirstPrincipalChild(); + while (cellFrame) { + // See if it's a table cell frame + if (IS_TABLE_CELL(cellFrame->GetType())) { + nsIFrame* continuingCellFrame = + CreateContinuingFrame(aPresContext, cellFrame, newFrame); + newChildList.AddChild(continuingCellFrame); + } + cellFrame = cellFrame->GetNextSibling(); + } + + // Set the table cell's initial child list + newFrame->SetInitialChildList(kPrincipalList, newChildList); + + } else if (IS_TABLE_CELL(frameType)) { + // 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(shell, styleContext, IsBorderCollapse(aParentFrame)); + + newFrame->Init(content, aParentFrame, aFrame); + if (newFrame->GetStateBits() & NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN) { + nsTableFrame::RegisterPositionedTablePart(newFrame); + } + + // Create a continuing area frame + nsIFrame* blockFrame = aFrame->GetFirstPrincipalChild(); + nsIFrame* continuingBlockFrame = + CreateContinuingFrame(aPresContext, blockFrame, newFrame); + + // Set the table cell's initial child list + SetInitialSingleChild(newFrame, continuingBlockFrame); + } else if (nsGkAtoms::lineFrame == frameType) { + newFrame = NS_NewFirstLineFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::letterFrame == frameType) { + newFrame = NS_NewFirstLetterFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::imageFrame == frameType) { + newFrame = NS_NewImageFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::imageControlFrame == frameType) { + newFrame = NS_NewImageControlFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::placeholderFrame == frameType) { + // create a continuing out of flow frame + nsIFrame* oofFrame = nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame); + nsIFrame* oofContFrame = + CreateContinuingFrame(aPresContext, oofFrame, aParentFrame); + newFrame = + CreatePlaceholderFrameFor(shell, content, oofContFrame, styleContext, + aParentFrame, aFrame, + aFrame->GetStateBits() & PLACEHOLDER_TYPE_MASK); + } else if (nsGkAtoms::fieldSetFrame == frameType) { + newFrame = NS_NewFieldSetFrame(shell, styleContext); + + newFrame->Init(content, aParentFrame, aFrame); + + // Create a continuing area frame + // XXXbz we really shouldn't have to do this by hand! + nsIFrame* blockFrame = GetFieldSetBlockFrame(aFrame); + if (blockFrame) { + nsIFrame* continuingBlockFrame = + CreateContinuingFrame(aPresContext, blockFrame, newFrame); + // Set the fieldset's initial child list + SetInitialSingleChild(newFrame, continuingBlockFrame); + } else { + MOZ_ASSERT(aFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER, + "FieldSet block may only be null for overflow containers"); + } + } else if (nsGkAtoms::legendFrame == frameType) { + newFrame = NS_NewLegendFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else if (nsGkAtoms::flexContainerFrame == frameType) { + newFrame = NS_NewFlexContainerFrame(shell, styleContext); + newFrame->Init(content, aParentFrame, aFrame); + } else { + NS_RUNTIMEABORT("unexpected frame type"); + } + + // Init() set newFrame to be a fluid continuation of aFrame. + // If we want a non-fluid continuation, we need to call SetPrevContinuation() + // to reset NS_FRAME_IS_FLUID_CONTINUATION. + if (!aIsFluid) { + newFrame->SetPrevContinuation(aFrame); + } + + // A continuation of generated content is also generated content + if (aFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT) { + newFrame->AddStateBits(NS_FRAME_GENERATED_CONTENT); + } + + // A continuation of nsIAnonymousContentCreator content is also + // nsIAnonymousContentCreator created content + if (aFrame->GetStateBits() & NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT) { + newFrame->AddStateBits(NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT); + } + + // A continuation of an out-of-flow is also an out-of-flow + if (aFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) { + newFrame->AddStateBits(NS_FRAME_OUT_OF_FLOW); + } + + if (nextInFlow) { + nextInFlow->SetPrevInFlow(newFrame); + newFrame->SetNextInFlow(nextInFlow); + } else if (nextContinuation) { + nextContinuation->SetPrevContinuation(newFrame); + newFrame->SetNextContinuation(nextContinuation); + } + + NS_POSTCONDITION(!newFrame->GetNextSibling(), "unexpected sibling"); + return newFrame; +} + +nsresult +nsCSSFrameConstructor::ReplicateFixedFrames(nsPageContentFrame* aParentFrame) +{ + // Now deal with fixed-pos things.... They should appear on all pages, + // so we want to move over the placeholders when processing the child + // of the pageContentFrame. + + nsIFrame* prevPageContentFrame = aParentFrame->GetPrevInFlow(); + if (!prevPageContentFrame) { + return NS_OK; + } + nsIFrame* canvasFrame = aParentFrame->GetFirstPrincipalChild(); + nsIFrame* prevCanvasFrame = prevPageContentFrame->GetFirstPrincipalChild(); + if (!canvasFrame || !prevCanvasFrame) { + // document's root element frame missing + return NS_ERROR_UNEXPECTED; + } + + nsFrameItems fixedPlaceholders; + nsIFrame* firstFixed = prevPageContentFrame->GetFirstChild(nsIFrame::kFixedList); + if (!firstFixed) { + return NS_OK; + } + + // Don't allow abs-pos descendants of the fixed content to escape the content. + // This should not normally be possible (because fixed-pos elements should + // be absolute containers) but fixed-pos tables currently aren't abs-pos + // containers. + nsFrameConstructorState state(mPresShell, aParentFrame, + nullptr, + mRootElementFrame); + state.mCreatingExtraFrames = true; + + // We can't use an ancestor filter here, because we're not going to + // be usefully recurring down the tree. This means that other + // places in frame construction can't assume a filter is + // initialized! + + // Iterate across fixed frames and replicate each whose placeholder is a + // descendant of aFrame. (We don't want to explicitly copy placeholders that + // are within fixed frames, because that would cause duplicates on the new + // page - bug 389619) + for (nsIFrame* fixed = firstFixed; fixed; fixed = fixed->GetNextSibling()) { + nsIFrame* prevPlaceholder = GetPlaceholderFrameFor(fixed); + if (prevPlaceholder && + nsLayoutUtils::IsProperAncestorFrame(prevCanvasFrame, prevPlaceholder)) { + // We want to use the same style as the primary style frame for + // our content + nsIContent* content = fixed->GetContent(); + nsStyleContext* styleContext = + nsLayoutUtils::GetStyleFrame(content)->StyleContext(); + FrameConstructionItemList items; + AddFrameConstructionItemsInternal(state, content, canvasFrame, + content->Tag(), + content->GetNameSpaceID(), + true, + styleContext, + ITEM_ALLOW_XBL_BASE | + ITEM_ALLOW_PAGE_BREAK, + nullptr, items); + ConstructFramesFromItemList(state, items, canvasFrame, fixedPlaceholders); + } + } + + // Add the placeholders to our primary child list. + // XXXbz this is a little screwed up, since the fixed frames will have + // broken auto-positioning. Oh, well. + NS_ASSERTION(!canvasFrame->GetFirstPrincipalChild(), + "leaking frames; doc root continuation must be empty"); + canvasFrame->SetInitialChildList(kPrincipalList, fixedPlaceholders); + return NS_OK; +} + +nsIFrame* +nsCSSFrameConstructor::GetInsertionPoint(nsIContent* aContainer, + nsIContent* aChildContent, + bool* aMultiple) +{ + nsBindingManager *bindingManager = mDocument->BindingManager(); + + nsIContent* insertionElement; + if (aChildContent) { + // We've got an explicit insertion child. Check to see if it's + // anonymous. + if (aChildContent->GetBindingParent() == aContainer) { + // This child content is anonymous. Don't use the insertion + // point, since that's only for the explicit kids. + return GetFrameFor(aContainer); + } + + insertionElement = bindingManager->FindNestedInsertionPoint(aContainer, aChildContent); + } + else { + bool multiple; + insertionElement = bindingManager->FindNestedSingleInsertionPoint(aContainer, &multiple); + + if (multiple) { + if (aMultiple) { + *aMultiple = true; + } + return nullptr; + } + } + + if (!insertionElement) { + insertionElement = aContainer; + } + + nsIFrame* insertionPoint = GetFrameFor(insertionElement); + + // fieldsets have multiple insertion points. Note that we might + // have to look at insertionElement here... + if (aMultiple && insertionElement->IsHTML(nsGkAtoms::fieldset)) { + *aMultiple = true; + } + + return insertionPoint; +} + +// Capture state for the frame tree rooted at the frame associated with the +// content object, aContent +void +nsCSSFrameConstructor::CaptureStateForFramesOf(nsIContent* aContent, + nsILayoutHistoryState* aHistoryState) +{ + if (!aHistoryState) { + return; + } + nsIFrame* frame = aContent->GetPrimaryFrame(); + if (frame == mRootElementFrame) { + frame = mFixedContainingBlock; + } + for ( ; frame; + frame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(frame)) { + CaptureFrameState(frame, aHistoryState); + } +} + +static bool EqualURIs(mozilla::css::URLValue *aURI1, + mozilla::css::URLValue *aURI2) +{ + return aURI1 == aURI2 || // handle null==null, and optimize + (aURI1 && aURI2 && aURI1->URIEquals(*aURI2)); +} + +nsresult +nsCSSFrameConstructor::MaybeRecreateFramesForElement(Element* aElement) +{ + nsRefPtr oldContext = GetUndisplayedContent(aElement); + if (!oldContext) { + return NS_OK; + } + + // The parent has a frame, so try resolving a new context. + nsRefPtr newContext = mPresShell->StyleSet()-> + ResolveStyleFor(aElement, oldContext->GetParent()); + + ChangeUndisplayedContent(aElement, newContext); + const nsStyleDisplay* disp = newContext->StyleDisplay(); + if (disp->mDisplay == NS_STYLE_DISPLAY_NONE) { + // We can skip trying to recreate frames here, but only if our style + // context does not have a binding URI that differs from our old one. + // Otherwise, we should try to recreate, because we may want to apply the + // new binding + if (!disp->mBinding) { + return NS_OK; + } + const nsStyleDisplay* oldDisp = oldContext->PeekStyleDisplay(); + if (oldDisp && EqualURIs(disp->mBinding, oldDisp->mBinding)) { + return NS_OK; + } + } + + return RecreateFramesForContent(aElement, false); +} + +static nsIFrame* +FindFirstNonWhitespaceChild(nsIFrame* aParentFrame) +{ + nsIFrame* f = aParentFrame->GetFirstPrincipalChild(); + while (f && f->GetType() == nsGkAtoms::textFrame && + f->GetContent()->TextIsOnlyWhitespace()) { + f = f->GetNextSibling(); + } + return f; +} + +static nsIFrame* +FindNextNonWhitespaceSibling(nsIFrame* aFrame) +{ + nsIFrame* f = aFrame; + do { + f = f->GetNextSibling(); + } while (f && f->GetType() == nsGkAtoms::textFrame && + f->GetContent()->TextIsOnlyWhitespace()); + return f; +} + +static nsIFrame* +FindPreviousNonWhitespaceSibling(nsIFrame* aFrame) +{ + nsIFrame* f = aFrame; + do { + f = f->GetPrevSibling(); + } while (f && f->GetType() == nsGkAtoms::textFrame && + f->GetContent()->TextIsOnlyWhitespace()); + return f; +} + +bool +nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame, + nsresult* aResult) +{ + NS_PRECONDITION(aFrame, "Must have a frame"); + NS_PRECONDITION(aFrame->GetParent(), "Frame shouldn't be root"); + NS_PRECONDITION(aResult, "Null out param?"); + NS_PRECONDITION(aFrame == aFrame->FirstContinuation(), + "aFrame not the result of GetPrimaryFrame()?"); + + if (IsFramePartOfIBSplit(aFrame)) { + // The removal functions can't handle removal of an {ib} split directly; we + // need to rebuild the containing block. +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: " + "frame="); + nsFrame::ListTag(stdout, aFrame); + printf(" is ib-split\n"); + } +#endif + + *aResult = ReframeContainingBlock(aFrame); + return true; + } + + if (aFrame->GetContentInsertionFrame()->GetType() == nsGkAtoms::legendFrame && + aFrame->GetParent()->GetType() == nsGkAtoms::fieldSetFrame) { + // When we remove the legend for a fieldset, we should reframe + // the fieldset to ensure another legend is used, if there is one + *aResult = RecreateFramesForContent(aFrame->GetParent()->GetContent(), false); + return true; + } + + // Now check for possibly needing to reconstruct due to a pseudo parent + nsIFrame* inFlowFrame = + (aFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) ? + GetPlaceholderFrameFor(aFrame) : aFrame; + MOZ_ASSERT(inFlowFrame, "How did that happen?"); + MOZ_ASSERT(inFlowFrame == inFlowFrame->FirstContinuation(), + "placeholder for primary frame has previous continuations?"); + nsIFrame* parent = inFlowFrame->GetParent(); + if (IsTablePseudo(parent)) { + if (FindFirstNonWhitespaceChild(parent) == inFlowFrame || + !FindNextNonWhitespaceSibling(inFlowFrame->LastContinuation()) || + // If we're a table-column-group, then the GetFirstChild check above is + // not going to catch cases when we're the first child. + (inFlowFrame->GetType() == nsGkAtoms::tableColGroupFrame && + parent->GetFirstChild(nsIFrame::kColGroupList) == inFlowFrame) || + // Similar if we're a table-caption. + (inFlowFrame->GetType() == nsGkAtoms::tableCaptionFrame && + parent->GetFirstChild(nsIFrame::kCaptionList) == inFlowFrame)) { + // We're the first or last frame in the pseudo. Need to reframe. + // Good enough to recreate frames for |parent|'s content + *aResult = RecreateFramesForContent(parent->GetContent(), true); + return true; + } + } + + // Might need to reconstruct things if this frame's nextSibling is a table + // pseudo, since removal of this frame might mean that this pseudo needs to + // get merged with the frame's prevSibling if that's also a table pseudo. + nsIFrame* nextSibling = + FindNextNonWhitespaceSibling(inFlowFrame->LastContinuation()); + NS_ASSERTION(!IsTablePseudo(inFlowFrame), "Shouldn't happen here"); + if (nextSibling && IsTablePseudo(nextSibling)) { + nsIFrame* prevSibling = FindPreviousNonWhitespaceSibling(inFlowFrame); + if (prevSibling && IsTablePseudo(prevSibling)) { +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: " + "frame="); + nsFrame::ListTag(stdout, aFrame); + printf(" has a table pseudo next sibling of different type and a " + "table pseudo prevsibling\n"); + } +#endif + // Good enough to recreate frames for aFrame's parent's content; even if + // aFrame's parent is a table pseudo, that'll be the right content node. + *aResult = RecreateFramesForContent(parent->GetContent(), true); + return true; + } + } + + // Might need to reconstruct things if the removed frame's nextSibling is an + // anonymous flex item. The removed frame might've been what divided two + // runs of inline content into two anonymous flex items, which would now + // need to be merged. + // NOTE: It's fine that we've advanced nextSibling past whitespace (up above); + // we're only interested in anonymous flex items here, and those can never + // be adjacent to whitespace, since they absorb contiguous runs of inline + // non-replaced content (including whitespace). + if (nextSibling && IsAnonymousFlexItem(nextSibling)) { + NS_ABORT_IF_FALSE(parent->GetType() == nsGkAtoms::flexContainerFrame, + "anonymous flex items should only exist as children " + "of flex container frames"); +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: " + "frame="); + nsFrame::ListTag(stdout, aFrame); + printf(" has an anonymous flex item as its next sibling\n"); + } +#endif // DEBUG + // Recreate frames for the flex container (the removed frame's parent) + *aResult = RecreateFramesForContent(parent->GetContent(), true); + return true; + } + + // Might need to reconstruct things if the removed frame's nextSibling is + // null and its parent is an anonymous flex item. (This might be the last + // remaining child of that anonymous flex item, which can then go away.) + if (!nextSibling && IsAnonymousFlexItem(parent)) { + NS_ABORT_IF_FALSE(parent->GetParent() && + parent->GetParent()->GetType() == nsGkAtoms::flexContainerFrame, + "anonymous flex items should only exist as children " + "of flex container frames"); +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: " + "frame="); + nsFrame::ListTag(stdout, aFrame); + printf(" has an anonymous flex item as its parent\n"); + } +#endif // DEBUG + // Recreate frames for the flex container (the removed frame's grandparent) + *aResult = RecreateFramesForContent(parent->GetParent()->GetContent(), + true); + return true; + } + +#ifdef MOZ_XUL + if (aFrame->GetType() == nsGkAtoms::popupSetFrame) { + nsIRootBox* rootBox = nsIRootBox::GetRootBox(mPresShell); + if (rootBox && rootBox->GetPopupSetFrame() == aFrame) { + *aResult = ReconstructDocElementHierarchy(); + return true; + } + } +#endif + + // Reconstruct if inflowFrame is parent's only child, and parent is, or has, + // a non-fluid continuation, i.e. it was split by bidi resolution + if (!inFlowFrame->GetPrevSibling() && + !inFlowFrame->GetNextSibling() && + ((parent->GetPrevContinuation() && !parent->GetPrevInFlow()) || + (parent->GetNextContinuation() && !parent->GetNextInFlow()))) { + *aResult = RecreateFramesForContent(parent->GetContent(), true); + return true; + } + + // We might still need to reconstruct things if the parent of inFlowFrame is + // ib-split, since in that case the removal of aFrame might affect the + // splitting of its parent. + if (!IsFramePartOfIBSplit(parent)) { + return false; + } + + // If inFlowFrame is not the only in-flow child of |parent|, then removing + // it will change nothing about the {ib} split. + if (inFlowFrame != parent->GetFirstPrincipalChild() || + inFlowFrame->LastContinuation()->GetNextSibling()) { + return false; + } + + // If the parent is the first or last part of the {ib} split, then + // removing one of its kids will have no effect on the splitting. + // Get the first continuation up front so we don't have to do it twice. + nsIFrame* parentFirstContinuation = parent->FirstContinuation(); + if (!GetIBSplitSibling(parentFirstContinuation) || + !GetIBSplitPrevSibling(parentFirstContinuation)) { + return false; + } + +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: " + "frame="); + nsFrame::ListTag(stdout, parent); + printf(" is ib-split\n"); + } +#endif + + *aResult = ReframeContainingBlock(parent); + return true; +} + +nsresult +nsCSSFrameConstructor::RecreateFramesForContent(nsIContent* aContent, + bool aAsyncInsert) +{ + NS_PRECONDITION(!aAsyncInsert || aContent->IsElement(), + "Can only insert elements async"); + // If there is no document, we don't want to recreate frames for it. (You + // shouldn't generally be giving this method content without a document + // anyway). + // Rebuilding the frame tree can have bad effects, especially if it's the + // frame tree for chrome (see bug 157322). + NS_ENSURE_TRUE(aContent->GetDocument(), NS_ERROR_FAILURE); + + // Is the frame ib-split? If so, we need to reframe the containing + // block *here*, rather than trying to remove and re-insert the + // content (which would otherwise result in *two* nested reframe + // containing block from ContentRemoved() and ContentInserted(), + // below!). We'd really like to optimize away one of those + // containing block reframes, hence the code here. + + nsIFrame* frame = aContent->GetPrimaryFrame(); + if (frame && frame->IsFrameOfType(nsIFrame::eMathML)) { + // Reframe the topmost MathML element to prevent exponential blowup + // (see bug 397518) + while (true) { + nsIContent* parentContent = aContent->GetParent(); + nsIFrame* parentContentFrame = parentContent->GetPrimaryFrame(); + if (!parentContentFrame || !parentContentFrame->IsFrameOfType(nsIFrame::eMathML)) + break; + aContent = parentContent; + frame = parentContentFrame; + } + } + + if (frame) { + nsIFrame* nonGeneratedAncestor = nsLayoutUtils::GetNonGeneratedAncestor(frame); + if (nonGeneratedAncestor->GetContent() != aContent) { + return RecreateFramesForContent(nonGeneratedAncestor->GetContent(), aAsyncInsert); + } + + if (frame->GetStateBits() & NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT) { + // Recreate the frames for the entire nsIAnonymousContentCreator tree + // since |frame| or one of its descendants may need an nsStyleContext + // that associates it to a CSS pseudo-element, and only the + // nsIAnonymousContentCreator that created this content knows how to make + // that happen. + nsIAnonymousContentCreator* acc = nullptr; + nsIFrame* ancestor = frame->GetParent(); + while (!(acc = do_QueryFrame(ancestor))) { + ancestor = ancestor->GetParent(); + } + NS_ASSERTION(acc, "Where is the nsIAnonymousContentCreator? We may fail " + "to recreate its content correctly"); + // nsSVGUseFrame is special, and we know this is unnecessary for it. + if (ancestor->GetType() != nsGkAtoms::svgUseFrame) { + NS_ASSERTION(aContent->IsInNativeAnonymousSubtree(), + "Why is NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT set?"); + return RecreateFramesForContent(ancestor->GetContent(), aAsyncInsert); + } + } + + nsIFrame* parent = frame->GetParent(); + nsIContent* parentContent = parent ? parent->GetContent() : nullptr; + // If the parent frame is a leaf then the subsequent insert will fail to + // create a frame, so we need to recreate the parent content. This happens + // with native anonymous content from the editor. + if (parent && parent->IsLeaf() && parentContent && + parentContent != aContent) { + return RecreateFramesForContent(parentContent, aAsyncInsert); + } + } + + nsresult rv = NS_OK; + + if (frame && MaybeRecreateContainerForFrameRemoval(frame, &rv)) { + return rv; + } + + nsINode* containerNode = aContent->GetParentNode(); + // XXXbz how can containerNode be null here? + if (containerNode) { + // Before removing the frames associated with the content object, + // ask them to save their state onto a temporary state object. + CaptureStateForFramesOf(aContent, mTempFrameTreeState); + + // Need the nsIContent parent, which might be null here, since we need to + // pass it to ContentInserted and ContentRemoved. + nsCOMPtr container = aContent->GetParent(); + + // Remove the frames associated with the content object. + bool didReconstruct; + rv = ContentRemoved(container, aContent, + aContent->IsRootOfAnonymousSubtree() ? + nullptr : + aContent->GetNextSibling(), + REMOVE_FOR_RECONSTRUCTION, &didReconstruct); + + if (NS_SUCCEEDED(rv) && !didReconstruct) { + // Now, recreate the frames associated with this content object. If + // ContentRemoved triggered reconstruction, then we don't need to do this + // because the frames will already have been built. + if (aAsyncInsert) { + RestyleManager()->PostRestyleEvent( + aContent->AsElement(), nsRestyleHint(0), nsChangeHint_ReconstructFrame); + } else { + rv = ContentInserted(container, aContent, mTempFrameTreeState, false); + } + } + } + + return rv; +} + +////////////////////////////////////////////////////////////////////// + +// Block frame construction code + +already_AddRefed +nsCSSFrameConstructor::GetFirstLetterStyle(nsIContent* aContent, + nsStyleContext* aStyleContext) +{ + if (aContent) { + return mPresShell->StyleSet()-> + ResolvePseudoElementStyle(aContent->AsElement(), + nsCSSPseudoElements::ePseudo_firstLetter, + aStyleContext, + nullptr); + } + return nullptr; +} + +already_AddRefed +nsCSSFrameConstructor::GetFirstLineStyle(nsIContent* aContent, + nsStyleContext* aStyleContext) +{ + if (aContent) { + return mPresShell->StyleSet()-> + ResolvePseudoElementStyle(aContent->AsElement(), + nsCSSPseudoElements::ePseudo_firstLine, + aStyleContext, + nullptr); + } + return nullptr; +} + +// Predicate to see if a given content (block element) has +// first-letter style applied to it. +bool +nsCSSFrameConstructor::ShouldHaveFirstLetterStyle(nsIContent* aContent, + nsStyleContext* aStyleContext) +{ + return nsLayoutUtils::HasPseudoStyle(aContent, aStyleContext, + nsCSSPseudoElements::ePseudo_firstLetter, + mPresShell->GetPresContext()); +} + +bool +nsCSSFrameConstructor::HasFirstLetterStyle(nsIFrame* aBlockFrame) +{ + NS_PRECONDITION(aBlockFrame, "Need a frame"); + NS_ASSERTION(nsLayoutUtils::GetAsBlock(aBlockFrame), + "Not a block frame?"); + + return (aBlockFrame->GetStateBits() & NS_BLOCK_HAS_FIRST_LETTER_STYLE) != 0; +} + +bool +nsCSSFrameConstructor::ShouldHaveFirstLineStyle(nsIContent* aContent, + nsStyleContext* aStyleContext) +{ + bool hasFirstLine = + nsLayoutUtils::HasPseudoStyle(aContent, aStyleContext, + nsCSSPseudoElements::ePseudo_firstLine, + mPresShell->GetPresContext()); + if (hasFirstLine) { + // But disable for fieldsets + int32_t namespaceID; + nsIAtom* tag = mDocument->BindingManager()->ResolveTag(aContent, + &namespaceID); + // This check must match the one in FindHTMLData. + hasFirstLine = tag != nsGkAtoms::fieldset || + namespaceID != kNameSpaceID_XHTML; + } + + return hasFirstLine; +} + +void +nsCSSFrameConstructor::ShouldHaveSpecialBlockStyle(nsIContent* aContent, + nsStyleContext* aStyleContext, + bool* aHaveFirstLetterStyle, + bool* aHaveFirstLineStyle) +{ + *aHaveFirstLetterStyle = + ShouldHaveFirstLetterStyle(aContent, aStyleContext); + *aHaveFirstLineStyle = + ShouldHaveFirstLineStyle(aContent, aStyleContext); +} + +/* static */ +const nsCSSFrameConstructor::PseudoParentData +nsCSSFrameConstructor::sPseudoParentData[eParentTypeCount] = { + { // Cell + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | FCDATA_SKIP_FRAMESET | + FCDATA_USE_CHILD_ITEMS | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeRow), + &nsCSSFrameConstructor::ConstructTableCell), + &nsCSSAnonBoxes::tableCell + }, + { // Row + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | FCDATA_SKIP_FRAMESET | + FCDATA_USE_CHILD_ITEMS | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeRowGroup), + &nsCSSFrameConstructor::ConstructTableRowOrRowGroup), + &nsCSSAnonBoxes::tableRow + }, + { // Row group + FULL_CTOR_FCDATA(FCDATA_IS_TABLE_PART | FCDATA_SKIP_FRAMESET | + FCDATA_USE_CHILD_ITEMS | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + &nsCSSFrameConstructor::ConstructTableRowOrRowGroup), + &nsCSSAnonBoxes::tableRowGroup + }, + { // Column group + FCDATA_DECL(FCDATA_IS_TABLE_PART | FCDATA_SKIP_FRAMESET | + FCDATA_DISALLOW_OUT_OF_FLOW | FCDATA_USE_CHILD_ITEMS | + FCDATA_SKIP_ABSPOS_PUSH | + FCDATA_DESIRED_PARENT_TYPE_TO_BITS(eTypeTable), + NS_NewTableColGroupFrame), + &nsCSSAnonBoxes::tableColGroup + }, + { // Table + FULL_CTOR_FCDATA(FCDATA_SKIP_FRAMESET | FCDATA_USE_CHILD_ITEMS, + &nsCSSFrameConstructor::ConstructTable), + &nsCSSAnonBoxes::table + } +}; + +void +nsCSSFrameConstructor::CreateNeededAnonFlexItems( + nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsIFrame* aParentFrame) +{ + if (aItems.IsEmpty() || + aParentFrame->GetType() != nsGkAtoms::flexContainerFrame) { + return; + } + + FCItemIterator iter(aItems); + do { + // Advance iter past children that don't want to be wrapped + if (iter.SkipItemsThatDontNeedAnonFlexItem(aState)) { + // Hit the end of the items without finding any remaining children that + // need to be wrapped. We're finished! + return; + } + + // If our next potentially-wrappable child is whitespace, then see if + // there's anything wrappable immediately after it. If not, we just drop + // the whitespace and move on. (We're not supposed to create any anonymous + // flex items that _only_ contain whitespace). + // (BUT if this is generated content, then we don't give whitespace nodes + // any special treatment, because they're probably not really whitespace -- + // they're just temporarily empty, waiting for their generated text.) + // XXXdholbert If this node's generated text will *actually end up being + // entirely whitespace*, then we technically should still skip over it, per + // the flexbox spec. I'm not bothering with that at this point, since it's + // a pretty extreme edge case. + if (!aParentFrame->IsGeneratedContentFrame() && + iter.item().IsWhitespace(aState)) { + FCItemIterator afterWhitespaceIter(iter); + bool hitEnd = afterWhitespaceIter.SkipWhitespace(aState); + bool nextChildNeedsAnonFlexItem = + !hitEnd && afterWhitespaceIter.item().NeedsAnonFlexItem(aState); + + if (!nextChildNeedsAnonFlexItem) { + // There's nothing after the whitespace that we need to wrap, so we + // just drop this run of whitespace. + iter.DeleteItemsTo(afterWhitespaceIter); + if (hitEnd) { + // Nothing left to do -- we're finished! + return; + } + // else, we have a next child and it does not want to be wrapped. So, + // we jump back to the beginning of the loop to skip over that child + // (and anything else non-wrappable after it) + NS_ABORT_IF_FALSE(!iter.IsDone() && + !iter.item().NeedsAnonFlexItem(aState), + "hitEnd and/or nextChildNeedsAnonFlexItem lied"); + continue; + } + } + + // Now |iter| points to the first child that needs to be wrapped in an + // anonymous flex item. Now we see how many children after it also want + // to be wrapped in an anonymous flex item. + FCItemIterator endIter(iter); // iterator to find the end of the group + endIter.SkipItemsThatNeedAnonFlexItem(aState); + + NS_ASSERTION(iter != endIter, + "Should've had at least one wrappable child to seek past"); + + // Now, we create the anonymous flex item to contain the children + // between |iter| and |endIter|. + nsIAtom* pseudoType = nsCSSAnonBoxes::anonymousFlexItem; + nsStyleContext* parentStyle = aParentFrame->StyleContext(); + nsIContent* parentContent = aParentFrame->GetContent(); + already_AddRefed wrapperStyle = + mPresShell->StyleSet()->ResolveAnonymousBoxStyle(pseudoType, parentStyle); + + static const FrameConstructionData sBlockFormattingContextFCData = + FCDATA_DECL(FCDATA_SKIP_FRAMESET | FCDATA_USE_CHILD_ITEMS, + NS_NewBlockFormattingContext); + + FrameConstructionItem* newItem = + new FrameConstructionItem(&sBlockFormattingContextFCData, + // Use the content of our parent frame + parentContent, + // Lie about the tag; it doesn't matter anyway + pseudoType, + iter.item().mNameSpaceID, + // no pending binding + nullptr, + wrapperStyle, + true, nullptr); + + newItem->mIsAllInline = newItem->mHasInlineEnds = + newItem->mStyleContext->StyleDisplay()->IsInlineOutsideStyle(); + newItem->mIsBlock = !newItem->mIsAllInline; + + NS_ABORT_IF_FALSE(!newItem->mIsAllInline && newItem->mIsBlock, + "expecting anonymous flex items to be block-level " + "(this will make a difference when we encounter " + "'flex-align: baseline')"); + + // Anonymous flex items induce line boundaries around their + // contents. + newItem->mChildItems.SetLineBoundaryAtStart(true); + newItem->mChildItems.SetLineBoundaryAtEnd(true); + // The parent of the items in aItems is also the parent of the items + // in mChildItems + newItem->mChildItems.SetParentHasNoXBLChildren( + aItems.ParentHasNoXBLChildren()); + + // Eat up all items between |iter| and |endIter| and put them in our + // wrapper. This advances |iter| to point to |endIter|. + iter.AppendItemsToList(endIter, newItem->mChildItems); + + iter.InsertItem(newItem); + } while (!iter.IsDone()); +} + +/* + * This function works as follows: we walk through the child list (aItems) and + * find items that cannot have aParentFrame as their parent. We wrap + * continuous runs of such items into a FrameConstructionItem for a frame that + * gets them closer to their desired parents. For example, a run of non-row + * children of a row-group will get wrapped in a row. When we later construct + * the frame for this wrapper (in this case for the row), it'll be the correct + * parent for the cells in the set of items we wrapped or we'll wrap cells + * around everything else. At the end of this method, aItems is guaranteed to + * contain only items for frames that can be direct kids of aParentFrame. + */ +void +nsCSSFrameConstructor::CreateNeededTablePseudos(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsIFrame* aParentFrame) +{ + ParentType ourParentType = GetParentType(aParentFrame); + if (aItems.AllWantParentType(ourParentType)) { + // Nothing to do here + return; + } + + FCItemIterator iter(aItems); + do { + if (iter.SkipItemsWantingParentType(ourParentType)) { + // Nothing else to do here; we're finished + return; + } + + // Now we're pointing to the first child that wants a different parent + // type. + + // Now try to figure out what kids we can group together. We can generally + // group everything that has a different desired parent type from us. Two + // exceptions to this: + // 1) If our parent type is table, we can't group columns with anything + // else other than whitespace. + // 2) Whitespace that lies between two things we can group which both want + // a non-block parent should be dropped, even if we can't group them + // with each other and even if the whitespace wants a parent of + // ourParentType. Ends of the list count as things that don't want a + // block parent (so that for example we'll drop a whitespace-only list). + + FCItemIterator endIter(iter); /* iterator to find the end of the group */ + ParentType groupingParentType = endIter.item().DesiredParentType(); + if (aItems.AllWantParentType(groupingParentType) && + groupingParentType != eTypeBlock) { + // Just group them all and be done with it. We need the check for + // eTypeBlock here to catch the "all the items are whitespace" case + // described above. + endIter.SetToEnd(); + } else { + // Locate the end of the group. + + // Keep track of the type the previous item wanted, in case we have to + // deal with whitespace. Start it off with ourParentType, since that's + // the last thing |iter| would have skipped over. + ParentType prevParentType = ourParentType; + do { + /* Walk an iterator past any whitespace that we might be able to drop from the list */ + FCItemIterator spaceEndIter(endIter); + if (prevParentType != eTypeBlock && + !aParentFrame->IsGeneratedContentFrame() && + spaceEndIter.item().IsWhitespace(aState)) { + bool trailingSpaces = spaceEndIter.SkipWhitespace(aState); + + // We drop the whitespace if these are not trailing spaces and the next item + // does not want a block parent (see case 2 above) + // if these are trailing spaces and aParentFrame is a tabular container + // according to rule 1.3 of CSS 2.1 Sec 17.2.1. (Being a tabular container + // pretty much means ourParentType != eTypeBlock besides the eTypeColGroup case, + // which won't reach here.) + if ((trailingSpaces && ourParentType != eTypeBlock) || + (!trailingSpaces && spaceEndIter.item().DesiredParentType() != + eTypeBlock)) { + bool updateStart = (iter == endIter); + endIter.DeleteItemsTo(spaceEndIter); + NS_ASSERTION(trailingSpaces == endIter.IsDone(), "These should match"); + + if (updateStart) { + iter = endIter; + } + + if (trailingSpaces) { + break; /* Found group end */ + } + + if (updateStart) { + // Update groupingParentType, since it might have been eTypeBlock + // just because of the whitespace. + groupingParentType = iter.item().DesiredParentType(); + } + } + } + + // Now endIter points to a non-whitespace item or a non-droppable + // whitespace item. In the latter case, if this is the end of the group + // we'll traverse this whitespace again. But it'll all just be quick + // DesiredParentType() checks which will match ourParentType (that's + // what it means that this is the group end), so it's OK. + prevParentType = endIter.item().DesiredParentType(); + if (prevParentType == ourParentType) { + // End the group at endIter. + break; + } + + if (ourParentType == eTypeTable && + (prevParentType == eTypeColGroup) != + (groupingParentType == eTypeColGroup)) { + // Either we started with columns and now found something else, or vice + // versa. In any case, end the grouping. + break; + } + + // Include the whitespace we didn't drop (if any) in the group, since + // this is not the end of the group. Note that this doesn't change + // prevParentType, since if we didn't drop the whitespace then we ended + // at something that wants a block parent. + endIter = spaceEndIter; + + endIter.Next(); + } while (!endIter.IsDone()); + } + + if (iter == endIter) { + // Nothing to wrap here; just skipped some whitespace + continue; + } + + // Now group together all the items between iter and endIter. The right + // parent type to use depends on ourParentType. + ParentType wrapperType; + switch (ourParentType) { + case eTypeBlock: + wrapperType = eTypeTable; + break; + case eTypeRow: + // The parent type for a cell is eTypeBlock, since that's what a cell + // looks like to its kids. + wrapperType = eTypeBlock; + break; + case eTypeRowGroup: + wrapperType = eTypeRow; + break; + case eTypeTable: + // Either colgroup or rowgroup, depending on what we're grouping. + wrapperType = groupingParentType == eTypeColGroup ? + eTypeColGroup : eTypeRowGroup; + break; + default: + MOZ_CRASH("Colgroups should be suppresing non-col child items"); + } + + const PseudoParentData& pseudoData = sPseudoParentData[wrapperType]; + nsIAtom* pseudoType = *pseudoData.mPseudoType; + nsStyleContext* parentStyle = aParentFrame->StyleContext(); + nsIContent* parentContent = aParentFrame->GetContent(); + + if (pseudoType == nsCSSAnonBoxes::table && + parentStyle->StyleDisplay()->mDisplay == NS_STYLE_DISPLAY_INLINE) { + pseudoType = nsCSSAnonBoxes::inlineTable; + } + + already_AddRefed wrapperStyle = + mPresShell->StyleSet()->ResolveAnonymousBoxStyle(pseudoType, parentStyle); + FrameConstructionItem* newItem = + new FrameConstructionItem(&pseudoData.mFCData, + // Use the content of our parent frame + parentContent, + // Lie about the tag; it doesn't matter anyway + pseudoType, + // The namespace does matter, however; it needs + // to match that of our first child item to + // match the old behavior + iter.item().mNameSpaceID, + // no pending binding + nullptr, + wrapperStyle, + true, nullptr); + + // Here we're cheating a tad... technically, table-internal items should be + // inline if aParentFrame is inline, but they'll get wrapped in an + // inline-table in the end, so it'll all work out. In any case, arguably + // we don't need to maintain this state at this point... but it's better + // to, I guess. + newItem->mIsAllInline = newItem->mHasInlineEnds = + newItem->mStyleContext->StyleDisplay()->IsInlineOutsideStyle(); + + // Table pseudo frames always induce line boundaries around their + // contents. + newItem->mChildItems.SetLineBoundaryAtStart(true); + newItem->mChildItems.SetLineBoundaryAtEnd(true); + // The parent of the items in aItems is also the parent of the items + // in mChildItems + newItem->mChildItems.SetParentHasNoXBLChildren( + aItems.ParentHasNoXBLChildren()); + + // Eat up all items between |iter| and |endIter| and put them in our wrapper + // Advances |iter| to point to |endIter|. + iter.AppendItemsToList(endIter, newItem->mChildItems); + + iter.InsertItem(newItem); + + // Now |iter| points to the item that was the first one we didn't wrap; + // loop and see whether we need to skip it or wrap it in something + // different. + } while (!iter.IsDone()); +} + +inline void +nsCSSFrameConstructor::ConstructFramesFromItemList(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsIFrame* aParentFrame, + nsFrameItems& aFrameItems) +{ + CreateNeededTablePseudos(aState, aItems, aParentFrame); + CreateNeededAnonFlexItems(aState, aItems, aParentFrame); + + aItems.SetTriedConstructingFrames(); + for (FCItemIterator iter(aItems); !iter.IsDone(); iter.Next()) { + NS_ASSERTION(iter.item().DesiredParentType() == GetParentType(aParentFrame), + "Needed pseudos didn't get created; expect bad things"); + ConstructFramesFromItem(aState, iter, aParentFrame, aFrameItems); + } + + NS_ASSERTION(!aState.mHavePendingPopupgroup, + "Should have proccessed it by now"); +} + +void +nsCSSFrameConstructor::AddFCItemsForAnonymousContent( + nsFrameConstructorState& aState, + nsIFrame* aFrame, + nsTArray& aAnonymousItems, + FrameConstructionItemList& aItemsToConstruct, + uint32_t aExtraFlags) +{ + for (uint32_t i = 0; i < aAnonymousItems.Length(); ++i) { + nsIContent* content = aAnonymousItems[i].mContent; +#ifdef DEBUG + nsIAnonymousContentCreator* creator = do_QueryFrame(aFrame); + NS_ASSERTION(!creator || !creator->CreateFrameFor(content), + "If you need to use CreateFrameFor, you need to call " + "CreateAnonymousFrames manually and not follow the standard " + "ProcessChildren() codepath for this frame"); +#endif + // Assert some things about this content + NS_ABORT_IF_FALSE(!(content->GetFlags() & + (NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME)), + "Should not be marked as needing frames"); + NS_ABORT_IF_FALSE(!content->IsElement() || + !(content->GetFlags() & ELEMENT_ALL_RESTYLE_FLAGS), + "Should have no pending restyle flags"); + NS_ABORT_IF_FALSE(!content->GetPrimaryFrame(), + "Should have no existing frame"); + NS_ABORT_IF_FALSE(!content->IsNodeOfType(nsINode::eCOMMENT) && + !content->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION), + "Why is someone creating garbage anonymous content"); + + nsRefPtr styleContext; + TreeMatchContext::AutoFlexItemStyleFixupSkipper + flexItemStyleFixupSkipper(aState.mTreeMatchContext); + if (aAnonymousItems[i].mStyleContext) { + styleContext = aAnonymousItems[i].mStyleContext.forget(); + } else { + styleContext = ResolveStyleContext(aFrame, content, &aState); + } + + nsTArray* anonChildren = nullptr; + if (!aAnonymousItems[i].mChildren.IsEmpty()) { + anonChildren = &aAnonymousItems[i].mChildren; + } + + uint32_t flags = ITEM_ALLOW_XBL_BASE | ITEM_ALLOW_PAGE_BREAK | + ITEM_IS_ANONYMOUSCONTENTCREATOR_CONTENT | aExtraFlags; + + AddFrameConstructionItemsInternal(aState, content, aFrame, + content->Tag(), content->GetNameSpaceID(), + true, styleContext, flags, + anonChildren, aItemsToConstruct); + } +} + +void +nsCSSFrameConstructor::ProcessChildren(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aStyleContext, + nsIFrame* aFrame, + const bool aCanHaveGeneratedContent, + nsFrameItems& aFrameItems, + const bool aAllowBlockStyles, + PendingBinding* aPendingBinding, + nsIFrame* aPossiblyLeafFrame) +{ + NS_PRECONDITION(aFrame, "Must have parent frame here"); + NS_PRECONDITION(aFrame->GetContentInsertionFrame() == aFrame, + "Parent frame in ProcessChildren should be its own " + "content insertion frame"); + const uint32_t kMaxDepth = 2 * MAX_REFLOW_DEPTH; + static_assert(kMaxDepth <= UINT16_MAX, "mCurrentDepth type is too narrow"); + AutoRestore savedDepth(mCurrentDepth); + if (mCurrentDepth != UINT16_MAX) { + ++mCurrentDepth; + } + + if (!aPossiblyLeafFrame) { + aPossiblyLeafFrame = aFrame; + } + + // XXXbz ideally, this would do all the pushing of various + // containing blocks as needed, so callers don't have to do it... + + bool haveFirstLetterStyle = false, haveFirstLineStyle = false; + if (aAllowBlockStyles) { + ShouldHaveSpecialBlockStyle(aContent, aStyleContext, &haveFirstLetterStyle, + &haveFirstLineStyle); + } + + // The logic here needs to match the logic in GetFloatContainingBlock() + nsFrameConstructorSaveState floatSaveState; + if (ShouldSuppressFloatingOfDescendants(aFrame)) { + aState.PushFloatContainingBlock(nullptr, floatSaveState); + } else if (aFrame->IsFloatContainingBlock()) { + aState.PushFloatContainingBlock(aFrame, floatSaveState); + } + + nsFrameConstructorState::PendingBindingAutoPusher pusher(aState, + aPendingBinding); + + FrameConstructionItemList itemsToConstruct; + + // If we have first-letter or first-line style then frames can get + // moved around so don't set these flags. + if (aAllowBlockStyles && !haveFirstLetterStyle && !haveFirstLineStyle) { + itemsToConstruct.SetLineBoundaryAtStart(true); + itemsToConstruct.SetLineBoundaryAtEnd(true); + } + + // Create any anonymous frames we need here. This must happen before the + // non-anonymous children are processed to ensure that popups are never + // constructed before the popupset. + nsAutoTArray anonymousItems; + GetAnonymousContent(aContent, aPossiblyLeafFrame, anonymousItems); +#ifdef DEBUG + for (uint32_t i = 0; i < anonymousItems.Length(); ++i) { + NS_ABORT_IF_FALSE(anonymousItems[i].mContent->IsRootOfAnonymousSubtree(), + "Content should know it's an anonymous subtree"); + } +#endif + AddFCItemsForAnonymousContent(aState, aFrame, anonymousItems, + itemsToConstruct); + + if (!aPossiblyLeafFrame->IsLeaf()) { + // :before/:after content should have the same style context parent + // as normal kids. + // Note that we don't use this style context for looking up things like + // special block styles because in some cases involving table pseudo-frames + // it has nothing to do with the parent frame's desired behavior. + nsStyleContext* styleContext; + + if (aCanHaveGeneratedContent) { + aFrame->AddStateBits(NS_FRAME_MAY_HAVE_GENERATED_CONTENT); + styleContext = + nsFrame::CorrectStyleParentFrame(aFrame, nullptr)->StyleContext(); + // Probe for generated content before + CreateGeneratedContentItem(aState, aFrame, aContent, styleContext, + nsCSSPseudoElements::ePseudo_before, + itemsToConstruct); + } + + const bool addChildItems = MOZ_LIKELY(mCurrentDepth < kMaxDepth); + if (!addChildItems) { + NS_WARNING("ProcessChildren max depth exceeded"); + } + + FlattenedChildIterator iter(aContent); + for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { + // Get the parent of the content and check if it is a XBL children element + // (if the content is a children element then parent != aContent because the + // FlattenedChildIterator will transitively iterate through + // for default content). Push the children element as an ancestor here because + // it does not have a frame and would not otherwise be pushed as an ancestor. + nsIContent* parent = child->GetParent(); + MOZ_ASSERT(parent, "Parent must be non-null because we are iterating children."); + TreeMatchContext::AutoAncestorPusher ancestorPusher(aState.mTreeMatchContext); + if (parent != aContent && parent->IsElement()) { + if (aState.mTreeMatchContext.mAncestorFilter.HasFilter()) { + ancestorPusher.PushAncestorAndStyleScope(parent->AsElement()); + } else { + ancestorPusher.PushStyleScope(parent->AsElement()); + } + } + + // Frame construction item construction should not post + // restyles, so removing restyle flags here is safe. + if (child->IsElement()) { + child->UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS); + } + if (addChildItems) { + AddFrameConstructionItems(aState, child, iter.XBLInvolved(), aFrame, + itemsToConstruct); + } else { + ClearLazyBits(child, child->GetNextSibling()); + } + } + itemsToConstruct.SetParentHasNoXBLChildren(!iter.XBLInvolved()); + + if (aCanHaveGeneratedContent) { + // Probe for generated content after + CreateGeneratedContentItem(aState, aFrame, aContent, styleContext, + nsCSSPseudoElements::ePseudo_after, + itemsToConstruct); + } + } else { + ClearLazyBits(aContent->GetFirstChild(), nullptr); + } + + ConstructFramesFromItemList(aState, itemsToConstruct, aFrame, aFrameItems); + + NS_ASSERTION(!aAllowBlockStyles || !aFrame->IsBoxFrame(), + "can't be both block and box"); + + if (haveFirstLetterStyle) { + WrapFramesInFirstLetterFrame(aContent, aFrame, aFrameItems); + } + if (haveFirstLineStyle) { + WrapFramesInFirstLineFrame(aState, aContent, aFrame, nullptr, + aFrameItems); + } + + // We might end up with first-line frames that change + // AnyKidsNeedBlockParent() without changing itemsToConstruct, but that + // should never happen for cases whan aFrame->IsBoxFrame(). + NS_ASSERTION(!haveFirstLineStyle || !aFrame->IsBoxFrame(), + "Shouldn't have first-line style if we're a box"); + NS_ASSERTION(!aFrame->IsBoxFrame() || + itemsToConstruct.AnyItemsNeedBlockParent() == + (AnyKidsNeedBlockParent(aFrameItems.FirstChild()) != nullptr), + "Something went awry in our block parent calculations"); + + if (aFrame->IsBoxFrame() && itemsToConstruct.AnyItemsNeedBlockParent()) { + // XXXbz we could do this on the FrameConstructionItemList level, + // no? And if we cared we could look through the item list + // instead of groveling through the framelist here.. + nsStyleContext *frameStyleContext = aFrame->StyleContext(); + // Report a warning for non-GC frames, for chrome: + if (!aFrame->IsGeneratedContentFrame() && + mPresShell->GetPresContext()->IsChrome()) { + nsIContent *badKid = AnyKidsNeedBlockParent(aFrameItems.FirstChild()); + nsDependentAtomString parentTag(aContent->Tag()), kidTag(badKid->Tag()); + const char16_t* params[] = { parentTag.get(), kidTag.get() }; + const nsStyleDisplay *display = frameStyleContext->StyleDisplay(); + const char *message = + (display->mDisplay == NS_STYLE_DISPLAY_INLINE_BOX) + ? "NeededToWrapXULInlineBox" : "NeededToWrapXUL"; + nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, + NS_LITERAL_CSTRING("FrameConstructor"), + mDocument, + nsContentUtils::eXUL_PROPERTIES, + message, + params, ArrayLength(params)); + } + + nsRefPtr blockSC = mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(nsCSSAnonBoxes::mozXULAnonymousBlock, + frameStyleContext); + nsIFrame *blockFrame = NS_NewBlockFrame(mPresShell, blockSC); + // We might, in theory, want to set NS_BLOCK_FLOAT_MGR and + // NS_BLOCK_MARGIN_ROOT, but I think it's a bad idea given that + // a real block placed here wouldn't get those set on it. + + InitAndRestoreFrame(aState, aContent, aFrame, blockFrame, false); + + NS_ASSERTION(!blockFrame->HasView(), "need to do view reparenting"); + ReparentFrames(this, blockFrame, aFrameItems); + + blockFrame->SetInitialChildList(kPrincipalList, aFrameItems); + NS_ASSERTION(aFrameItems.IsEmpty(), "How did that happen?"); + aFrameItems.Clear(); + aFrameItems.AddChild(blockFrame); + + aFrame->AddStateBits(NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK); + } +} + +//---------------------------------------------------------------------- + +// Support for :first-line style + +// Special routine to handle placing a list of frames into a block +// frame that has first-line style. The routine ensures that the first +// collection of inline frames end up in a first-line frame. +// NOTE: aState may have containing block information related to a +// different part of the frame tree than where the first line occurs. +// In particular aState may be set up for where ContentInserted or +// ContentAppended is inserting content, which may be some +// non-first-in-flow continuation of the block to which the first-line +// belongs. So this function needs to be careful about how it uses +// aState. +void +nsCSSFrameConstructor::WrapFramesInFirstLineFrame( + nsFrameConstructorState& aState, + nsIContent* aBlockContent, + nsIFrame* aBlockFrame, + nsIFrame* aLineFrame, + nsFrameItems& aFrameItems) +{ + // Find the part of aFrameItems that we want to put in the first-line + nsFrameList::FrameLinkEnumerator link(aFrameItems); + while (!link.AtEnd() && link.NextFrame()->IsInlineOutside()) { + link.Next(); + } + + nsFrameList firstLineChildren = aFrameItems.ExtractHead(link); + + if (firstLineChildren.IsEmpty()) { + // Nothing is supposed to go into the first-line; nothing to do + return; + } + + if (!aLineFrame) { + // Create line frame + nsStyleContext* parentStyle = + nsFrame::CorrectStyleParentFrame(aBlockFrame, + nsCSSPseudoElements::firstLine)-> + StyleContext(); + nsRefPtr firstLineStyle = GetFirstLineStyle(aBlockContent, + parentStyle); + + aLineFrame = NS_NewFirstLineFrame(mPresShell, firstLineStyle); + + // Initialize the line frame + InitAndRestoreFrame(aState, aBlockContent, aBlockFrame, aLineFrame); + + // The lineFrame will be the block's first child; the rest of the + // frame list (after lastInlineFrame) will be the second and + // subsequent children; insert lineFrame into aFrameItems. + aFrameItems.InsertFrame(nullptr, nullptr, aLineFrame); + + NS_ASSERTION(aLineFrame->StyleContext() == firstLineStyle, + "Bogus style context on line frame"); + } + + // Give the inline frames to the lineFrame after reparenting them + ReparentFrames(this, aLineFrame, firstLineChildren); + if (aLineFrame->PrincipalChildList().IsEmpty() && + (aLineFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW)) { + aLineFrame->SetInitialChildList(kPrincipalList, firstLineChildren); + } else { + AppendFrames(aLineFrame, kPrincipalList, firstLineChildren); + } +} + +// Special routine to handle appending a new frame to a block frame's +// child list. Takes care of placing the new frame into the right +// place when first-line style is present. +void +nsCSSFrameConstructor::AppendFirstLineFrames( + nsFrameConstructorState& aState, + nsIContent* aBlockContent, + nsIFrame* aBlockFrame, + nsFrameItems& aFrameItems) +{ + // It's possible that aBlockFrame needs to have a first-line frame + // created because it doesn't currently have any children. + const nsFrameList& blockKids = aBlockFrame->PrincipalChildList(); + if (blockKids.IsEmpty()) { + WrapFramesInFirstLineFrame(aState, aBlockContent, + aBlockFrame, nullptr, aFrameItems); + return; + } + + // Examine the last block child - if it's a first-line frame then + // appended frames need special treatment. + nsIFrame* lastBlockKid = blockKids.LastChild(); + if (lastBlockKid->GetType() != nsGkAtoms::lineFrame) { + // No first-line frame at the end of the list, therefore there is + // an intervening block between any first-line frame the frames + // we are appending. Therefore, we don't need any special + // treatment of the appended frames. + return; + } + + WrapFramesInFirstLineFrame(aState, aBlockContent, aBlockFrame, + lastBlockKid, aFrameItems); +} + +// Special routine to handle inserting a new frame into a block +// frame's child list. Takes care of placing the new frame into the +// right place when first-line style is present. +nsresult +nsCSSFrameConstructor::InsertFirstLineFrames( + nsFrameConstructorState& aState, + nsIContent* aContent, + nsIFrame* aBlockFrame, + nsIFrame** aParentFrame, + nsIFrame* aPrevSibling, + nsFrameItems& aFrameItems) +{ + nsresult rv = NS_OK; + // XXXbz If you make this method actually do something, check to + // make sure that the caller is passing what you expect. In + // particular, which content is aContent? And audit the rest of + // this code too; it makes bogus assumptions and may not build. +#if 0 + nsIFrame* parentFrame = *aParentFrame; + nsIFrame* newFrame = aFrameItems.childList; + bool isInline = IsInlineOutside(newFrame); + + if (!aPrevSibling) { + // Insertion will become the first frame. Two cases: we either + // already have a first-line frame or we don't. + nsIFrame* firstBlockKid = aBlockFrame->GetFirstPrincipalChild(); + if (firstBlockKid->GetType() == nsGkAtoms::lineFrame) { + // We already have a first-line frame + nsIFrame* lineFrame = firstBlockKid; + + if (isInline) { + // Easy case: the new inline frame will go into the lineFrame. + ReparentFrame(this, lineFrame, newFrame); + InsertFrames(lineFrame, kPrincipalList, nullptr, newFrame); + + // Since the frame is going into the lineFrame, don't let it + // go into the block too. + aFrameItems.childList = nullptr; + aFrameItems.lastChild = nullptr; + } + else { + // Harder case: We are about to insert a block level element + // before the first-line frame. + // XXX need a method to steal away frames from the line-frame + } + } + else { + // We do not have a first-line frame + if (isInline) { + // We now need a first-line frame to contain the inline frame. + nsIFrame* lineFrame = NS_NewFirstLineFrame(firstLineStyle); + + if (NS_SUCCEEDED(rv)) { + // Lookup first-line style context + nsStyleContext* parentStyle = + nsFrame::CorrectStyleParentFrame(aBlockFrame, + nsCSSPseudoElements::firstLine)-> + StyleContext(); + nsRefPtr firstLineStyle = + GetFirstLineStyle(aContent, parentStyle); + + // Initialize the line frame + InitAndRestoreFrame(aState, aContent, aBlockFrame, lineFrame); + + // Make sure the caller inserts the lineFrame into the + // blocks list of children. + aFrameItems.childList = lineFrame; + aFrameItems.lastChild = lineFrame; + + // Give the inline frames to the lineFrame after + // reparenting them + NS_ASSERTION(lineFrame->StyleContext() == firstLineStyle, + "Bogus style context on line frame"); + ReparentFrame(aPresContext, lineFrame, newFrame); + lineFrame->SetInitialChildList(kPrincipalList, newFrame); + } + } + else { + // Easy case: the regular insertion logic can insert the new + // frame because it's a block frame. + } + } + } + else { + // Insertion will not be the first frame. + nsIFrame* prevSiblingParent = aPrevSibling->GetParent(); + if (prevSiblingParent == aBlockFrame) { + // Easy case: The prev-siblings parent is the block + // frame. Therefore the prev-sibling is not currently in a + // line-frame. Therefore the new frame which is going after it, + // regardless of type, is not going into a line-frame. + } + else { + // If the prevSiblingParent is not the block-frame then it must + // be a line-frame (if it were a letter-frame, that logic would + // already have adjusted the prev-sibling to be the + // letter-frame). + if (isInline) { + // Easy case: the insertion can go where the caller thinks it + // should go (which is into prevSiblingParent). + } + else { + // Block elements don't end up in line-frames, therefore + // change the insertion point to aBlockFrame. However, there + // might be more inline elements following aPrevSibling that + // need to be pulled out of the line-frame and become children + // of the block. + nsIFrame* nextSibling = aPrevSibling->GetNextSibling(); + nsIFrame* nextLineFrame = prevSiblingParent->GetNextInFlow(); + if (nextSibling || nextLineFrame) { + // Oy. We have work to do. Create a list of the new frames + // that are going into the block by stripping them away from + // the line-frame(s). + if (nextSibling) { + nsLineFrame* lineFrame = (nsLineFrame*) prevSiblingParent; + nsFrameList tail = lineFrame->StealFramesAfter(aPrevSibling); + // XXX do something with 'tail' + } + + nsLineFrame* nextLineFrame = (nsLineFrame*) lineFrame; + for (;;) { + nextLineFrame = nextLineFrame->GetNextInFlow(); + if (!nextLineFrame) { + break; + } + nsIFrame* kids = nextLineFrame->GetFirstPrincipalChild(); + } + } + else { + // We got lucky: aPrevSibling was the last inline frame in + // the line-frame. + ReparentFrame(this, aBlockFrame, newFrame); + InsertFrames(aBlockFrame, kPrincipalList, + prevSiblingParent, newFrame); + aFrameItems.childList = nullptr; + aFrameItems.lastChild = nullptr; + } + } + } + } + +#endif + return rv; +} + +//---------------------------------------------------------------------- + +// First-letter support + +// Determine how many characters in the text fragment apply to the +// first letter +static int32_t +FirstLetterCount(const nsTextFragment* aFragment) +{ + int32_t count = 0; + int32_t firstLetterLength = 0; + + int32_t i, n = aFragment->GetLength(); + for (i = 0; i < n; i++) { + char16_t ch = aFragment->CharAt(i); + // FIXME: take content language into account when deciding whitespace. + if (dom::IsSpaceCharacter(ch)) { + if (firstLetterLength) { + break; + } + count++; + continue; + } + // XXX I18n + if ((ch == '\'') || (ch == '\"')) { + if (firstLetterLength) { + break; + } + // keep looping + firstLetterLength = 1; + } + else { + count++; + break; + } + } + + return count; +} + +static bool +NeedFirstLetterContinuation(nsIContent* aContent) +{ + NS_PRECONDITION(aContent, "null ptr"); + + bool result = false; + if (aContent) { + const nsTextFragment* frag = aContent->GetText(); + if (frag) { + int32_t flc = FirstLetterCount(frag); + int32_t tl = frag->GetLength(); + if (flc < tl) { + result = true; + } + } + } + return result; +} + +static bool IsFirstLetterContent(nsIContent* aContent) +{ + return aContent->TextLength() && + !aContent->TextIsOnlyWhitespace(); +} + +/** + * Create a letter frame, only make it a floating frame. + */ +void +nsCSSFrameConstructor::CreateFloatingLetterFrame( + nsFrameConstructorState& aState, + nsIFrame* aBlockFrame, + nsIContent* aTextContent, + nsIFrame* aTextFrame, + nsIContent* aBlockContent, + nsIFrame* aParentFrame, + nsStyleContext* aStyleContext, + nsFrameItems& aResult) +{ + // Create the first-letter-frame + nsIFrame* letterFrame; + nsStyleSet *styleSet = mPresShell->StyleSet(); + + letterFrame = NS_NewFirstLetterFrame(mPresShell, aStyleContext); + // We don't want to use a text content for a non-text frame (because we want + // its primary frame to be a text frame). So use its parent for the + // first-letter. + nsIContent* letterContent = aTextContent->GetParent(); + nsIFrame* containingBlock = aState.GetGeometricParent( + aStyleContext->StyleDisplay(), aParentFrame); + InitAndRestoreFrame(aState, letterContent, containingBlock, letterFrame); + + // Init the text frame to refer to the letter frame. Make sure we + // get a proper style context for it (the one passed in is for the + // letter frame and will have the float property set on it; the text + // frame shouldn't have that set). + nsRefPtr textSC; + textSC = styleSet->ResolveStyleForNonElement(aStyleContext); + aTextFrame->SetStyleContextWithoutNotification(textSC); + InitAndRestoreFrame(aState, aTextContent, letterFrame, aTextFrame); + + // And then give the text frame to the letter frame + SetInitialSingleChild(letterFrame, aTextFrame); + + // See if we will need to continue the text frame (does it contain + // more than just the first-letter text or not?) If it does, then we + // create (in advance) a continuation frame for it. + nsIFrame* nextTextFrame = nullptr; + if (NeedFirstLetterContinuation(aTextContent)) { + // Create continuation + nextTextFrame = + CreateContinuingFrame(aState.mPresContext, aTextFrame, aParentFrame); + // Repair the continuations style context + nsStyleContext* parentStyleContext = aStyleContext->GetParent(); + if (parentStyleContext) { + nsRefPtr newSC; + newSC = styleSet->ResolveStyleForNonElement(parentStyleContext); + nextTextFrame->SetStyleContext(newSC); + } + } + + NS_ASSERTION(aResult.IsEmpty(), "aResult should be an empty nsFrameItems!"); + // Put the new float before any of the floats in the block we're doing + // first-letter for, that is, before any floats whose parent is + // containingBlock. + nsFrameList::FrameLinkEnumerator link(aState.mFloatedItems); + while (!link.AtEnd() && link.NextFrame()->GetParent() != containingBlock) { + link.Next(); + } + + aState.AddChild(letterFrame, aResult, letterContent, aStyleContext, + aParentFrame, false, true, false, true, + link.PrevFrame()); + + if (nextTextFrame) { + aResult.AddChild(nextTextFrame); + } +} + +/** + * Create a new letter frame for aTextFrame. The letter frame will be + * a child of aParentFrame. + */ +void +nsCSSFrameConstructor::CreateLetterFrame(nsIFrame* aBlockFrame, + nsIFrame* aBlockContinuation, + nsIContent* aTextContent, + nsIFrame* aParentFrame, + nsFrameItems& aResult) +{ + NS_PRECONDITION(aTextContent->IsNodeOfType(nsINode::eTEXT), + "aTextContent isn't text"); + NS_ASSERTION(nsLayoutUtils::GetAsBlock(aBlockFrame), + "Not a block frame?"); + + // Get style context for the first-letter-frame + nsStyleContext* parentStyleContext = + nsFrame::CorrectStyleParentFrame(aParentFrame, + nsCSSPseudoElements::firstLetter)-> + StyleContext(); + + // Use content from containing block so that we can actually + // find a matching style rule. + nsIContent* blockContent = aBlockFrame->GetContent(); + + // Create first-letter style rule + nsRefPtr sc = GetFirstLetterStyle(blockContent, + parentStyleContext); + if (sc) { + nsRefPtr textSC; + textSC = mPresShell->StyleSet()->ResolveStyleForNonElement(sc); + + // Create a new text frame (the original one will be discarded) + // pass a temporary stylecontext, the correct one will be set + // later. Start off by unsetting the primary frame for + // aTextContent, so it's no longer pointing to the to-be-destroyed + // frame. + // XXXbz it would be really nice to destroy the old frame _first_, + // then create the new one, so we could avoid this hack. + aTextContent->SetPrimaryFrame(nullptr); + nsIFrame* textFrame = NS_NewTextFrame(mPresShell, textSC); + + NS_ASSERTION(aBlockContinuation == GetFloatContainingBlock(aParentFrame), + "Containing block is confused"); + nsFrameConstructorState state(mPresShell, + GetAbsoluteContainingBlock(aParentFrame, FIXED_POS), + GetAbsoluteContainingBlock(aParentFrame, ABS_POS), + aBlockContinuation); + + // Create the right type of first-letter frame + const nsStyleDisplay* display = sc->StyleDisplay(); + if (display->IsFloatingStyle() && !aParentFrame->IsSVGText()) { + // Make a floating first-letter frame + CreateFloatingLetterFrame(state, aBlockFrame, aTextContent, textFrame, + blockContent, aParentFrame, sc, aResult); + } + else { + // Make an inflow first-letter frame + nsIFrame* letterFrame = NS_NewFirstLetterFrame(mPresShell, sc); + + // Initialize the first-letter-frame. We don't want to use a text + // content for a non-text frame (because we want its primary frame to + // be a text frame). So use its parent for the first-letter. + nsIContent* letterContent = aTextContent->GetParent(); + letterFrame->Init(letterContent, aParentFrame, nullptr); + + InitAndRestoreFrame(state, aTextContent, letterFrame, textFrame); + + SetInitialSingleChild(letterFrame, textFrame); + aResult.Clear(); + aResult.AddChild(letterFrame); + NS_ASSERTION(!aBlockFrame->GetPrevContinuation(), + "should have the first continuation here"); + aBlockFrame->AddStateBits(NS_BLOCK_HAS_FIRST_LETTER_CHILD); + } + aTextContent->SetPrimaryFrame(textFrame); + } +} + +void +nsCSSFrameConstructor::WrapFramesInFirstLetterFrame( + nsIContent* aBlockContent, + nsIFrame* aBlockFrame, + nsFrameItems& aBlockFrames) +{ + aBlockFrame->AddStateBits(NS_BLOCK_HAS_FIRST_LETTER_STYLE); + + nsIFrame* parentFrame = nullptr; + nsIFrame* textFrame = nullptr; + nsIFrame* prevFrame = nullptr; + nsFrameItems letterFrames; + bool stopLooking = false; + WrapFramesInFirstLetterFrame(aBlockFrame, aBlockFrame, aBlockFrame, + aBlockFrames.FirstChild(), + &parentFrame, &textFrame, &prevFrame, + letterFrames, &stopLooking); + if (parentFrame) { + if (parentFrame == aBlockFrame) { + // Take textFrame out of the block's frame list and substitute the + // letter frame(s) instead. + aBlockFrames.DestroyFrame(textFrame); + aBlockFrames.InsertFrames(nullptr, prevFrame, letterFrames); + } + else { + // Take the old textFrame out of the inline parent's child list + RemoveFrame(kPrincipalList, textFrame); + + // Insert in the letter frame(s) + parentFrame->InsertFrames(kPrincipalList, prevFrame, letterFrames); + } + } +} + +void +nsCSSFrameConstructor::WrapFramesInFirstLetterFrame( + nsIFrame* aBlockFrame, + nsIFrame* aBlockContinuation, + nsIFrame* aParentFrame, + nsIFrame* aParentFrameList, + nsIFrame** aModifiedParent, + nsIFrame** aTextFrame, + nsIFrame** aPrevFrame, + nsFrameItems& aLetterFrames, + bool* aStopLooking) +{ + nsIFrame* prevFrame = nullptr; + nsIFrame* frame = aParentFrameList; + + while (frame) { + nsIFrame* nextFrame = frame->GetNextSibling(); + + nsIAtom* frameType = frame->GetType(); + if (nsGkAtoms::textFrame == frameType) { + // Wrap up first-letter content in a letter frame + nsIContent* textContent = frame->GetContent(); + if (IsFirstLetterContent(textContent)) { + // Create letter frame to wrap up the text + CreateLetterFrame(aBlockFrame, aBlockContinuation, textContent, + aParentFrame, aLetterFrames); + + // Provide adjustment information for parent + *aModifiedParent = aParentFrame; + *aTextFrame = frame; + *aPrevFrame = prevFrame; + *aStopLooking = true; + return; + } + } + else if (IsInlineFrame(frame) && frameType != nsGkAtoms::brFrame) { + nsIFrame* kids = frame->GetFirstPrincipalChild(); + WrapFramesInFirstLetterFrame(aBlockFrame, aBlockContinuation, frame, + kids, aModifiedParent, aTextFrame, + aPrevFrame, aLetterFrames, aStopLooking); + if (*aStopLooking) { + return; + } + } + else { + // This will stop us looking to create more letter frames. For + // example, maybe the frame-type is "letterFrame" or + // "placeholderFrame". This keeps us from creating extra letter + // frames, and also prevents us from creating letter frames when + // the first real content child of a block is not text (e.g. an + // image, hr, etc.) + *aStopLooking = true; + break; + } + + prevFrame = frame; + frame = nextFrame; + } +} + +static nsIFrame* +FindFirstLetterFrame(nsIFrame* aFrame, nsIFrame::ChildListID aListID) +{ + nsFrameList list = aFrame->GetChildList(aListID); + for (nsFrameList::Enumerator e(list); !e.AtEnd(); e.Next()) { + if (nsGkAtoms::letterFrame == e.get()->GetType()) { + return e.get(); + } + } + return nullptr; +} + +nsresult +nsCSSFrameConstructor::RemoveFloatingFirstLetterFrames( + nsPresContext* aPresContext, + nsIPresShell* aPresShell, + nsIFrame* aBlockFrame, + bool* aStopLooking) +{ + // Look for the first letter frame on the kFloatList, then kPushedFloatsList. + nsIFrame* floatFrame = + ::FindFirstLetterFrame(aBlockFrame, nsIFrame::kFloatList); + if (!floatFrame) { + floatFrame = + ::FindFirstLetterFrame(aBlockFrame, nsIFrame::kPushedFloatsList); + if (!floatFrame) { + return NS_OK; + } + } + + // Take the text frame away from the letter frame (so it isn't + // destroyed when we destroy the letter frame). + nsIFrame* textFrame = floatFrame->GetFirstPrincipalChild(); + if (!textFrame) { + return NS_OK; + } + + // Discover the placeholder frame for the letter frame + nsIFrame* parentFrame; + nsPlaceholderFrame* placeholderFrame = GetPlaceholderFrameFor(floatFrame); + + if (!placeholderFrame) { + // Somethings really wrong + return NS_OK; + } + parentFrame = placeholderFrame->GetParent(); + if (!parentFrame) { + // Somethings really wrong + return NS_OK; + } + + // Create a new text frame with the right style context that maps + // all of the content that was previously part of the letter frame + // (and probably continued elsewhere). + nsStyleContext* parentSC = parentFrame->StyleContext(); + nsIContent* textContent = textFrame->GetContent(); + if (!textContent) { + return NS_OK; + } + nsRefPtr newSC; + newSC = aPresShell->StyleSet()->ResolveStyleForNonElement(parentSC); + nsIFrame* newTextFrame = NS_NewTextFrame(aPresShell, newSC); + newTextFrame->Init(textContent, parentFrame, nullptr); + + // Destroy the old text frame's continuations (the old text frame + // will be destroyed when its letter frame is destroyed). + nsIFrame* frameToDelete = textFrame->LastContinuation(); + while (frameToDelete != textFrame) { + nsIFrame* nextFrameToDelete = frameToDelete->GetPrevContinuation(); + RemoveFrame(kPrincipalList, frameToDelete); + frameToDelete = nextFrameToDelete; + } + + nsIFrame* prevSibling = placeholderFrame->GetPrevSibling(); + + // Now that everything is set... +#ifdef NOISY_FIRST_LETTER + printf("RemoveFloatingFirstLetterFrames: textContent=%p oldTextFrame=%p newTextFrame=%p\n", + textContent.get(), textFrame, newTextFrame); +#endif + + // Remove placeholder frame and the float + RemoveFrame(kPrincipalList, placeholderFrame); + + // Now that the old frames are gone, we can start pointing to our + // new primary frame. + textContent->SetPrimaryFrame(newTextFrame); + + // Wallpaper bug 822910. + bool offsetsNeedFixing = + prevSibling && prevSibling->GetType() == nsGkAtoms::textFrame; + if (offsetsNeedFixing) { + prevSibling->AddStateBits(TEXT_OFFSETS_NEED_FIXING); + } + + // Insert text frame in its place + nsFrameList textList(newTextFrame, newTextFrame); + InsertFrames(parentFrame, kPrincipalList, prevSibling, textList); + + if (offsetsNeedFixing) { + prevSibling->RemoveStateBits(TEXT_OFFSETS_NEED_FIXING); + } + + return NS_OK; +} + +nsresult +nsCSSFrameConstructor::RemoveFirstLetterFrames(nsPresContext* aPresContext, + nsIPresShell* aPresShell, + nsIFrame* aFrame, + nsIFrame* aBlockFrame, + bool* aStopLooking) +{ + nsIFrame* prevSibling = nullptr; + nsIFrame* kid = aFrame->GetFirstPrincipalChild(); + + while (kid) { + if (nsGkAtoms::letterFrame == kid->GetType()) { + // Bingo. Found it. First steal away the text frame. + nsIFrame* textFrame = kid->GetFirstPrincipalChild(); + if (!textFrame) { + break; + } + + // Create a new textframe + nsStyleContext* parentSC = aFrame->StyleContext(); + if (!parentSC) { + break; + } + nsIContent* textContent = textFrame->GetContent(); + if (!textContent) { + break; + } + nsRefPtr newSC; + newSC = aPresShell->StyleSet()->ResolveStyleForNonElement(parentSC); + textFrame = NS_NewTextFrame(aPresShell, newSC); + textFrame->Init(textContent, aFrame, nullptr); + + // Next rip out the kid and replace it with the text frame + RemoveFrame(kPrincipalList, kid); + + // Now that the old frames are gone, we can start pointing to our + // new primary frame. + textContent->SetPrimaryFrame(textFrame); + + // Wallpaper bug 822910. + bool offsetsNeedFixing = + prevSibling && prevSibling->GetType() == nsGkAtoms::textFrame; + if (offsetsNeedFixing) { + prevSibling->AddStateBits(TEXT_OFFSETS_NEED_FIXING); + } + + // Insert text frame in its place + nsFrameList textList(textFrame, textFrame); + InsertFrames(aFrame, kPrincipalList, prevSibling, textList); + + if (offsetsNeedFixing) { + prevSibling->RemoveStateBits(TEXT_OFFSETS_NEED_FIXING); + } + + *aStopLooking = true; + NS_ASSERTION(!aBlockFrame->GetPrevContinuation(), + "should have the first continuation here"); + aBlockFrame->RemoveStateBits(NS_BLOCK_HAS_FIRST_LETTER_CHILD); + break; + } + else if (IsInlineFrame(kid)) { + // Look inside child inline frame for the letter frame + RemoveFirstLetterFrames(aPresContext, aPresShell, + kid, aBlockFrame, aStopLooking); + if (*aStopLooking) { + break; + } + } + prevSibling = kid; + kid = kid->GetNextSibling(); + } + + return NS_OK; +} + +nsresult +nsCSSFrameConstructor::RemoveLetterFrames(nsPresContext* aPresContext, + nsIPresShell* aPresShell, + nsIFrame* aBlockFrame) +{ + aBlockFrame = aBlockFrame->FirstContinuation(); + nsIFrame* continuation = aBlockFrame; + + bool stopLooking = false; + nsresult rv; + do { + rv = RemoveFloatingFirstLetterFrames(aPresContext, aPresShell, + continuation, &stopLooking); + if (NS_SUCCEEDED(rv) && !stopLooking) { + rv = RemoveFirstLetterFrames(aPresContext, aPresShell, + continuation, aBlockFrame, &stopLooking); + } + if (stopLooking) { + break; + } + continuation = continuation->GetNextContinuation(); + } while (continuation); + return rv; +} + +// Fixup the letter frame situation for the given block +void +nsCSSFrameConstructor::RecoverLetterFrames(nsIFrame* aBlockFrame) +{ + aBlockFrame = aBlockFrame->FirstContinuation(); + nsIFrame* continuation = aBlockFrame; + + nsIFrame* parentFrame = nullptr; + nsIFrame* textFrame = nullptr; + nsIFrame* prevFrame = nullptr; + nsFrameItems letterFrames; + bool stopLooking = false; + do { + // XXX shouldn't this bit be set already (bug 408493), assert instead? + continuation->AddStateBits(NS_BLOCK_HAS_FIRST_LETTER_STYLE); + WrapFramesInFirstLetterFrame(aBlockFrame, continuation, continuation, + continuation->GetFirstPrincipalChild(), + &parentFrame, &textFrame, &prevFrame, + letterFrames, &stopLooking); + if (stopLooking) { + break; + } + continuation = continuation->GetNextContinuation(); + } while (continuation); + + if (parentFrame) { + // Take the old textFrame out of the parents child list + RemoveFrame(kPrincipalList, textFrame); + + // Insert in the letter frame(s) + parentFrame->InsertFrames(kPrincipalList, prevFrame, letterFrames); + } +} + +//---------------------------------------------------------------------- + +// listbox Widget Routines + +nsresult +nsCSSFrameConstructor::CreateListBoxContent(nsPresContext* aPresContext, + nsIFrame* aParentFrame, + nsIFrame* aPrevFrame, + nsIContent* aChild, + nsIFrame** aNewFrame, + bool aIsAppend, + bool aIsScrollbar, + nsILayoutHistoryState* aFrameState) +{ +#ifdef MOZ_XUL + nsresult rv = NS_OK; + + // Construct a new frame + if (nullptr != aParentFrame) { + nsFrameItems frameItems; + nsFrameConstructorState state(mPresShell, GetAbsoluteContainingBlock(aParentFrame, FIXED_POS), + GetAbsoluteContainingBlock(aParentFrame, ABS_POS), + GetFloatContainingBlock(aParentFrame), + mTempFrameTreeState); + + // If we ever initialize the ancestor filter on |state|, make sure + // to push the right parent! + + nsRefPtr styleContext; + styleContext = ResolveStyleContext(aParentFrame, aChild, &state); + + // Pre-check for display "none" - only if we find that, do we create + // any frame at all + const nsStyleDisplay* display = styleContext->StyleDisplay(); + + if (NS_STYLE_DISPLAY_NONE == display->mDisplay) { + *aNewFrame = nullptr; + return NS_OK; + } + + BeginUpdate(); + + FrameConstructionItemList items; + AddFrameConstructionItemsInternal(state, aChild, aParentFrame, + aChild->Tag(), aChild->GetNameSpaceID(), + true, styleContext, + ITEM_ALLOW_XBL_BASE, nullptr, items); + ConstructFramesFromItemList(state, items, aParentFrame, frameItems); + + nsIFrame* newFrame = frameItems.FirstChild(); + *aNewFrame = newFrame; + + if (newFrame) { + // Notify the parent frame + if (aIsAppend) + rv = ((nsListBoxBodyFrame*)aParentFrame)->ListBoxAppendFrames(frameItems); + else + rv = ((nsListBoxBodyFrame*)aParentFrame)->ListBoxInsertFrames(aPrevFrame, frameItems); + } + + EndUpdate(); + +#ifdef ACCESSIBILITY + if (newFrame) { + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + accService->ContentRangeInserted(mPresShell, aChild->GetParent(), + aChild, aChild->GetNextSibling()); + } + } +#endif + } + + return rv; +#else + return NS_ERROR_FAILURE; +#endif +} + +//---------------------------------------- + +void +nsCSSFrameConstructor::ConstructBlock(nsFrameConstructorState& aState, + const nsStyleDisplay* aDisplay, + nsIContent* aContent, + nsIFrame* aParentFrame, + nsIFrame* aContentParentFrame, + nsStyleContext* aStyleContext, + nsIFrame** aNewFrame, + nsFrameItems& aFrameItems, + nsIFrame* aPositionedFrameForAbsPosContainer, + PendingBinding* aPendingBinding) +{ + // Create column wrapper if necessary + nsIFrame* blockFrame = *aNewFrame; + NS_ASSERTION(blockFrame->GetType() == nsGkAtoms::blockFrame, "not a block frame?"); + nsIFrame* parent = aParentFrame; + nsRefPtr blockStyle = aStyleContext; + const nsStyleColumn* columns = aStyleContext->StyleColumn(); + + if (columns->mColumnCount != NS_STYLE_COLUMN_COUNT_AUTO + || columns->mColumnWidth.GetUnit() != eStyleUnit_Auto) { + nsIFrame* columnSetFrame = nullptr; + columnSetFrame = + NS_NewColumnSetFrame(mPresShell, aStyleContext, nsFrameState(0)); + + InitAndRestoreFrame(aState, aContent, aParentFrame, columnSetFrame); + blockStyle = mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(nsCSSAnonBoxes::columnContent, aStyleContext); + parent = columnSetFrame; + *aNewFrame = columnSetFrame; + + SetInitialSingleChild(columnSetFrame, blockFrame); + } + + blockFrame->SetStyleContextWithoutNotification(blockStyle); + InitAndRestoreFrame(aState, aContent, parent, blockFrame); + + aState.AddChild(*aNewFrame, aFrameItems, aContent, aStyleContext, + aContentParentFrame ? aContentParentFrame : + aParentFrame); + if (!mRootElementFrame) { + // The frame we're constructing will be the root element frame. + // Set mRootElementFrame before processing children. + mRootElementFrame = *aNewFrame; + } + + // We should make the outer frame be the absolute containing block, + // if one is required. We have to do this because absolute + // positioning must be computed with respect to the CSS dimensions + // of the element, which are the dimensions of the outer block. But + // we can't really do that because only blocks can have absolute + // children. So use the block and try to compensate with hacks + // in nsBlockFrame::CalculateContainingBlockSizeForAbsolutes. + nsFrameConstructorSaveState absoluteSaveState; + (*aNewFrame)->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN); + if (aPositionedFrameForAbsPosContainer) { + // NS_ASSERTION(aRelPos, "should have made area frame for this"); + aState.PushAbsoluteContainingBlock(*aNewFrame, aPositionedFrameForAbsPosContainer, absoluteSaveState); + } + + // Process the child content + nsFrameItems childItems; + ProcessChildren(aState, aContent, aStyleContext, blockFrame, true, + childItems, true, aPendingBinding); + + // Set the frame's initial child list + blockFrame->SetInitialChildList(kPrincipalList, childItems); +} + +nsIFrame* +nsCSSFrameConstructor::ConstructInline(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsIFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems) +{ + // If an inline frame has non-inline kids, then we chop up the child list + // into runs of blocks and runs of inlines, create anonymous block frames to + // contain the runs of blocks, inline frames with our style context for the + // runs of inlines, and put all these frames, in order, into aFrameItems. We + // return the the first one. The whole setup is called an {ib} + // split; in what follows "frames in the split" refers to the anonymous blocks + // and inlines that contain our children. + // + // {ib} splits maintain the following invariants: + // 1) All frames in the split have the NS_FRAME_PART_OF_IBSPLIT bit + // set. + // 2) Each frame in the split has the nsIFrame::IBSplitSibling + // property pointing to the next frame in the split, except for the last + // one, which does not have it set. + // 3) Each frame in the split has the nsIFrame::IBSplitPrevSibling + // property pointing to the previous frame in the split, except for the + // first one, which does not have it set. + // 4) The first and last frame in the split are always inlines. + // + // An invariant that is NOT maintained is that the wrappers are actually + // linked via GetNextSibling linkage. A simple example is an inline + // containing an inline that contains a block. The three parts of the inner + // inline end up with three different parents. + // + // For example, this HTML: + // + //
a
+ // + // b + //
c
+ // + // d + //
e
+ // f + // + // Gives the following frame tree: + // + // Inline (outer span) + // Block (anonymous, outer span) + // Block (div) + // Text("a") + // Inline (outer span) + // Inline (inner span) + // Text("b") + // Block (anonymous, outer span) + // Block (anonymous, inner span) + // Block (div) + // Text("c") + // Inline (outer span) + // Inline (inner span) + // Text("d") + // Block (anonymous, outer span) + // Block (div) + // Text("e") + // Inline (outer span) + // Text("f") + + nsIContent* const content = aItem.mContent; + nsStyleContext* const styleContext = aItem.mStyleContext; + + bool positioned = + NS_STYLE_DISPLAY_INLINE == aDisplay->mDisplay && + aDisplay->IsRelativelyPositionedStyle() && + !aParentFrame->IsSVGText(); + + nsIFrame* newFrame = NS_NewInlineFrame(mPresShell, styleContext); + + // Initialize the frame + InitAndRestoreFrame(aState, content, aParentFrame, newFrame); + + // Inline frames can always have generated content + newFrame->AddStateBits(NS_FRAME_MAY_HAVE_GENERATED_CONTENT); + + nsFrameConstructorSaveState absoluteSaveState; // definition cannot be inside next block + // because the object's destructor is significant + // this is part of the fix for bug 42372 + + newFrame->AddStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN); + if (positioned) { + // Relatively positioned frames becomes a container for child + // frames that are positioned + aState.PushAbsoluteContainingBlock(newFrame, newFrame, absoluteSaveState); + } + + // Process the child content + nsFrameItems childItems; + ConstructFramesFromItemList(aState, aItem.mChildItems, newFrame, childItems); + + nsFrameList::FrameLinkEnumerator firstBlockEnumerator(childItems); + if (!aItem.mIsAllInline) { + FindFirstBlock(firstBlockEnumerator); + } + + if (aItem.mIsAllInline || firstBlockEnumerator.AtEnd()) { + // This part is easy. We either already know we have no non-inline kids, + // or haven't found any when constructing actual frames (the latter can + // happen only if out-of-flows that we thought had no containing block + // acquired one when ancestor inline frames and {ib} splits got + // constructed). Just put all the kids into the single inline frame and + // bail. + newFrame->SetInitialChildList(kPrincipalList, childItems); + aState.AddChild(newFrame, aFrameItems, content, styleContext, aParentFrame); + return newFrame; + } + + // This inline frame contains several types of children. Therefore this frame + // has to be chopped into several pieces, as described above. + + // Grab the first inline's kids + nsFrameList firstInlineKids = childItems.ExtractHead(firstBlockEnumerator); + newFrame->SetInitialChildList(kPrincipalList, firstInlineKids); + + aFrameItems.AddChild(newFrame); + + CreateIBSiblings(aState, newFrame, positioned, childItems, aFrameItems); + + return newFrame; +} + +void +nsCSSFrameConstructor::CreateIBSiblings(nsFrameConstructorState& aState, + nsIFrame* aInitialInline, + bool aIsPositioned, + nsFrameItems& aChildItems, + nsFrameItems& aSiblings) +{ + nsIContent* content = aInitialInline->GetContent(); + nsStyleContext* styleContext = aInitialInline->StyleContext(); + nsIFrame* parentFrame = aInitialInline->GetParent(); + + // Resolve the right style context for our anonymous blocks. + // The distinction in styles is needed because of CSS 2.1, section + // 9.2.1.1, which says: + // When such an inline box is affected by relative positioning, any + // resulting translation also affects the block-level box contained + // in the inline box. + nsRefPtr blockSC = + mPresShell->StyleSet()-> + ResolveAnonymousBoxStyle(aIsPositioned ? + nsCSSAnonBoxes::mozAnonymousPositionedBlock : + nsCSSAnonBoxes::mozAnonymousBlock, + styleContext); + + nsIFrame* lastNewInline = aInitialInline->FirstContinuation(); + do { + // On entry to this loop aChildItems is not empty and the first frame in it + // is block-level. + NS_PRECONDITION(aChildItems.NotEmpty(), "Should have child items"); + NS_PRECONDITION(!aChildItems.FirstChild()->IsInlineOutside(), + "Must have list starting with block"); + + // The initial run of blocks belongs to an anonymous block that we create + // right now. The anonymous block will be the parent of these block + // children of the inline. + nsIFrame* blockFrame; + blockFrame = NS_NewBlockFrame(mPresShell, blockSC); + + InitAndRestoreFrame(aState, content, parentFrame, blockFrame, false); + + // Find the first non-block child which defines the end of our block kids + // and the start of our next inline's kids + nsFrameList::FrameLinkEnumerator firstNonBlock = + FindFirstNonBlock(aChildItems); + nsFrameList blockKids = aChildItems.ExtractHead(firstNonBlock); + + MoveChildrenTo(aState.mPresContext, aInitialInline, blockFrame, blockKids); + + SetFrameIsIBSplit(lastNewInline, blockFrame); + aSiblings.AddChild(blockFrame); + + // Now grab the initial inlines in aChildItems and put them into an inline + // frame + nsIFrame* inlineFrame = NS_NewInlineFrame(mPresShell, styleContext); + + InitAndRestoreFrame(aState, content, parentFrame, inlineFrame, false); + + inlineFrame->AddStateBits(NS_FRAME_MAY_HAVE_GENERATED_CONTENT | + NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN); + if (aIsPositioned) { + inlineFrame->MarkAsAbsoluteContainingBlock(); + } + + if (aChildItems.NotEmpty()) { + nsFrameList::FrameLinkEnumerator firstBlock(aChildItems); + FindFirstBlock(firstBlock); + nsFrameList inlineKids = aChildItems.ExtractHead(firstBlock); + + MoveChildrenTo(aState.mPresContext, aInitialInline, inlineFrame, + inlineKids); + } + + SetFrameIsIBSplit(blockFrame, inlineFrame); + aSiblings.AddChild(inlineFrame); + lastNewInline = inlineFrame; + } while (aChildItems.NotEmpty()); + + SetFrameIsIBSplit(lastNewInline, nullptr); +} + +void +nsCSSFrameConstructor::BuildInlineChildItems(nsFrameConstructorState& aState, + FrameConstructionItem& aParentItem, + bool aItemIsWithinSVGText, + bool aItemAllowsTextPathChild) +{ + // XXXbz should we preallocate aParentItem.mChildItems to some sane + // length? Maybe even to parentContent->GetChildCount()? + nsFrameConstructorState::PendingBindingAutoPusher + pusher(aState, aParentItem.mPendingBinding); + + nsStyleContext* const parentStyleContext = aParentItem.mStyleContext; + nsIContent* const parentContent = aParentItem.mContent; + + TreeMatchContext::AutoAncestorPusher ancestorPusher(aState.mTreeMatchContext); + if (aState.mTreeMatchContext.mAncestorFilter.HasFilter()) { + ancestorPusher.PushAncestorAndStyleScope(parentContent->AsElement()); + } else { + ancestorPusher.PushStyleScope(parentContent->AsElement()); + } + + if (!aItemIsWithinSVGText) { + // Probe for generated content before + CreateGeneratedContentItem(aState, nullptr, parentContent, parentStyleContext, + nsCSSPseudoElements::ePseudo_before, + aParentItem.mChildItems); + } + + uint32_t flags = ITEM_ALLOW_XBL_BASE | ITEM_ALLOW_PAGE_BREAK; + if (aItemIsWithinSVGText) { + flags |= ITEM_IS_WITHIN_SVG_TEXT; + } + if (aItemAllowsTextPathChild && aParentItem.mIsForSVGAElement) { + flags |= ITEM_ALLOWS_TEXT_PATH_CHILD; + } + + if (!aParentItem.mAnonChildren.IsEmpty()) { + // Use the anon-children list instead of the content tree child list so + // that we use any special style context that should be associated with + // the children, and so that we won't try to construct grandchildren frame + // constructor items before the frame is available for their parent. + AddFCItemsForAnonymousContent(aState, nullptr, aParentItem.mAnonChildren, + aParentItem.mChildItems, flags); + } else { + // Use the content tree child list: + FlattenedChildIterator iter(parentContent); + for (nsIContent* content = iter.GetNextChild(); content; content = iter.GetNextChild()) { + // Get the parent of the content and check if it is a XBL children element + // (if the content is a children element then contentParent != parentContent because the + // FlattenedChildIterator will transitively iterate through + // for default content). Push the children element as an ancestor here because + // it does not have a frame and would not otherwise be pushed as an ancestor. + nsIContent* contentParent = content->GetParent(); + MOZ_ASSERT(contentParent, "Parent must be non-null because we are iterating children."); + TreeMatchContext::AutoAncestorPusher insertionPointPusher(aState.mTreeMatchContext); + if (contentParent != parentContent && contentParent->IsElement()) { + if (aState.mTreeMatchContext.mAncestorFilter.HasFilter()) { + insertionPointPusher.PushAncestorAndStyleScope(contentParent->AsElement()); + } else { + insertionPointPusher.PushStyleScope(contentParent->AsElement()); + } + } + + // Manually check for comments/PIs, since we don't have a frame to pass to + // AddFrameConstructionItems. We know our parent is a non-replaced inline, + // so there is no need to do the NeedFrameFor check. + content->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME); + if (content->IsNodeOfType(nsINode::eCOMMENT) || + content->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION)) { + continue; + } + if (content->IsElement()) { + // See comment explaining why we need to remove the "is possible + // restyle root" flags in AddFrameConstructionItems. But note + // that we can remove all restyle flags, just like in + // ProcessChildren and for the same reason. + content->UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS); + } + + nsRefPtr childContext = + ResolveStyleContext(parentStyleContext, content, &aState); + + AddFrameConstructionItemsInternal(aState, content, nullptr, content->Tag(), + content->GetNameSpaceID(), + iter.XBLInvolved(), childContext, + flags, nullptr, + aParentItem.mChildItems); + } + } + + if (!aItemIsWithinSVGText) { + // Probe for generated content after + CreateGeneratedContentItem(aState, nullptr, parentContent, parentStyleContext, + nsCSSPseudoElements::ePseudo_after, + aParentItem.mChildItems); + } + + aParentItem.mIsAllInline = aParentItem.mChildItems.AreAllItemsInline(); +} + +// return whether it's ok to append (in the AppendFrames sense) to +// aParentFrame if our nextSibling is aNextSibling. aParentFrame must +// be an ib-split inline. +static bool +IsSafeToAppendToIBSplitInline(nsIFrame* aParentFrame, nsIFrame* aNextSibling) +{ + NS_PRECONDITION(IsInlineFrame(aParentFrame), + "Must have an inline parent here"); + do { + NS_ASSERTION(IsFramePartOfIBSplit(aParentFrame), + "How is this not part of an ib-split?"); + if (aNextSibling || aParentFrame->GetNextContinuation() || + GetIBSplitSibling(aParentFrame)) { + return false; + } + + aNextSibling = aParentFrame->GetNextSibling(); + aParentFrame = aParentFrame->GetParent(); + } while (IsInlineFrame(aParentFrame)); + + return true; +} + +bool +nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState, + nsIFrame* aContainingBlock, + nsIFrame* aFrame, + FrameConstructionItemList& aItems, + bool aIsAppend, + nsIFrame* aPrevSibling) +{ + if (aItems.IsEmpty()) { + return false; + } + + // Before we go and append the frames, we must check for several + // special situations. + + // Situation #1 is a XUL frame that contains frames that are required + // to be wrapped in blocks. + if (aFrame->IsBoxFrame() && + !(aFrame->GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK) && + aItems.AnyItemsNeedBlockParent()) { + RecreateFramesForContent(aFrame->GetContent(), true); + return true; + } + + nsIFrame* nextSibling = ::GetInsertNextSibling(aFrame, aPrevSibling); + + // Situation #2 is a flex container frame into which we're inserting new + // inline non-replaced children, adjacent to an existing anonymous flex item. + if (aFrame->GetType() == nsGkAtoms::flexContainerFrame) { + FCItemIterator iter(aItems); + + // Check if we're adding to-be-wrapped content right *after* an existing + // anonymous flex item (which would need to absorb this content). + if (aPrevSibling && IsAnonymousFlexItem(aPrevSibling) && + iter.item().NeedsAnonFlexItem(aState)) { + RecreateFramesForContent(aFrame->GetContent(), true); + return true; + } + + // Check if we're adding to-be-wrapped content right *before* an existing + // anonymous flex item (which would need to absorb this content). + if (nextSibling && IsAnonymousFlexItem(nextSibling)) { + // Jump to the last entry in the list + iter.SetToEnd(); + iter.Prev(); + if (iter.item().NeedsAnonFlexItem(aState)) { + RecreateFramesForContent(aFrame->GetContent(), true); + return true; + } + } + } + + // Situation #3 is an anonymous flex item that's getting new children who + // don't want to be wrapped. + if (IsAnonymousFlexItem(aFrame)) { + nsIFrame* flexContainerFrame = aFrame->GetParent(); + NS_ABORT_IF_FALSE(flexContainerFrame && + flexContainerFrame->GetType() == nsGkAtoms::flexContainerFrame, + "anonymous flex items should only exist as children " + "of flex container frames"); + + // We need to push a null float containing block to be sure that + // "NeedsAnonFlexItem" will know we're not honoring floats for this + // inserted content. (In particular, this is necessary in order for + // NeedsAnonFlexItem's "GetGeometricParent" call to return the correct + // result.) We're not honoring floats on this content because it has the + // _flex container_ as its parent in the content tree. + nsFrameConstructorSaveState floatSaveState; + aState.PushFloatContainingBlock(nullptr, floatSaveState); + + FCItemIterator iter(aItems); + // Skip over things that _do_ need an anonymous flex item, because + // they're perfectly happy to go here -- they won't cause a reframe. + if (!iter.SkipItemsThatNeedAnonFlexItem(aState)) { + // We hit something that _doesn't_ need an anonymous flex item! + // Rebuild the flex container to bust it out. + RecreateFramesForContent(flexContainerFrame->GetContent(), true); + return true; + } + + // If we get here, then everything in |aItems| needs to be wrapped in + // an anonymous flex item. That's where it's already going - good! + } + + // Situation #4 is a case when table pseudo-frames don't work out right + ParentType parentType = GetParentType(aFrame); + // If all the kids want a parent of the type that aFrame is, then we're all + // set to go. Indeed, there won't be any table pseudo-frames created between + // aFrame and the kids, so those won't need to be merged with any table + // pseudo-frames that might already be kids of aFrame. If aFrame itself is a + // table pseudo-frame, then all the kids in this list would have wanted a + // frame of that type wrapping them anyway, so putting them inside it is ok. + if (!aItems.AllWantParentType(parentType)) { + // Don't give up yet. If parentType is not eTypeBlock and the parent is + // not a generated content frame, then try filtering whitespace out of the + // list. + if (parentType != eTypeBlock && !aFrame->IsGeneratedContentFrame()) { + // For leading whitespace followed by a kid that wants our parent type, + // there are four cases: + // 1) We have a previous sibling which is not a table pseudo. That means + // that previous sibling wanted a (non-block) parent of the type we're + // looking at. Then the whitespace comes between two table-internal + // elements, so should be collapsed out. + // 2) We have a previous sibling which is a table pseudo. It might have + // kids who want this whitespace, so we need to reframe. + // 3) We have no previous sibling and our parent frame is not a table + // pseudo. That means that we'll be at the beginning of our actual + // non-block-type parent, and the whitespace is OK to collapse out. + // If something is ever inserted before us, it'll find our own parent + // as its parent and if it's something that would care about the + // whitespace it'll want a block parent, so it'll trigger a reframe at + // that point. + // 4) We have no previous sibling and our parent frame is a table pseudo. + // Need to reframe. + // All that is predicated on finding the correct previous sibling. We + // might have to walk backwards along continuations from aFrame to do so. + // + // It's always OK to drop whitespace between any two items that want a + // parent of type parentType. + // + // For trailing whitespace preceded by a kid that wants our parent type, + // there are four cases: + // 1) We have a next sibling which is not a table pseudo. That means + // that next sibling wanted a (non-block) parent of the type we're + // looking at. Then the whitespace comes between two table-internal + // elements, so should be collapsed out. + // 2) We have a next sibling which is a table pseudo. It might have + // kids who want this whitespace, so we need to reframe. + // 3) We have no next sibling and our parent frame is not a table + // pseudo. That means that we'll be at the end of our actual + // non-block-type parent, and the whitespace is OK to collapse out. + // If something is ever inserted after us, it'll find our own parent + // as its parent and if it's something that would care about the + // whitespace it'll want a block parent, so it'll trigger a reframe at + // that point. + // 4) We have no next sibling and our parent frame is a table pseudo. + // Need to reframe. + // All that is predicated on finding the correct next sibling. We might + // have to walk forward along continuations from aFrame to do so. That + // said, in the case when nextSibling is null at this point and aIsAppend + // is true, we know we're in case 3. Furthermore, in that case we don't + // even have to worry about the table pseudo situation; we know our + // parent is not a table pseudo there. + FCItemIterator iter(aItems); + FCItemIterator start(iter); + do { + if (iter.SkipItemsWantingParentType(parentType)) { + break; + } + + // iter points to an item that wants a different parent. If it's not + // whitespace, we're done; no more point scanning the list. + if (!iter.item().IsWhitespace(aState)) { + break; + } + + if (iter == start) { + // Leading whitespace. How to handle this depends on our + // previous sibling and aFrame. See the long comment above. + nsIFrame* prevSibling = aPrevSibling; + if (!prevSibling) { + // Try to find one after all + nsIFrame* parentPrevCont = aFrame->GetPrevContinuation(); + while (parentPrevCont) { + prevSibling = parentPrevCont->GetLastChild(kPrincipalList); + if (prevSibling) { + break; + } + parentPrevCont = parentPrevCont->GetPrevContinuation(); + } + }; + if (prevSibling) { + if (IsTablePseudo(prevSibling)) { + // need to reframe + break; + } + } else if (IsTablePseudo(aFrame)) { + // need to reframe + break; + } + } + + FCItemIterator spaceEndIter(iter); + // Advance spaceEndIter past any whitespace + bool trailingSpaces = spaceEndIter.SkipWhitespace(aState); + + bool okToDrop; + if (trailingSpaces) { + // Trailing whitespace. How to handle this depeds on aIsAppend, our + // next sibling and aFrame. See the long comment above. + okToDrop = aIsAppend && !nextSibling; + if (!okToDrop) { + if (!nextSibling) { + // Try to find one after all + nsIFrame* parentNextCont = aFrame->GetNextContinuation(); + while (parentNextCont) { + nextSibling = parentNextCont->GetFirstPrincipalChild(); + if (nextSibling) { + break; + } + parentNextCont = parentNextCont->GetNextContinuation(); + } + } + + okToDrop = (nextSibling && !IsTablePseudo(nextSibling)) || + (!nextSibling && !IsTablePseudo(aFrame)); + } +#ifdef DEBUG + else { + NS_ASSERTION(!IsTablePseudo(aFrame), "How did that happen?"); + } +#endif + } else { + okToDrop = (spaceEndIter.item().DesiredParentType() == parentType); + } + + if (okToDrop) { + iter.DeleteItemsTo(spaceEndIter); + } else { + // We're done: we don't want to drop the whitespace, and it has the + // wrong parent type. + break; + } + + // Now loop, since |iter| points to item right after the whitespace we + // removed. + } while (!iter.IsDone()); + } + + // We might be able to figure out some sort of optimizations here, but they + // would have to depend on having a correct aPrevSibling and a correct next + // sibling. For example, we can probably avoid reframing if none of + // aFrame, aPrevSibling, and next sibling are table pseudo-frames. But it + // doesn't seem worth it to worry about that for now, especially since we + // in fact do not have a reliable aPrevSibling, nor any next sibling, in + // this method. + + // aItems might have changed, so recheck the parent type thing. In fact, + // it might be empty, so recheck that too. + if (aItems.IsEmpty()) { + return false; + } + + if (!aItems.AllWantParentType(parentType)) { + // Reframing aFrame->GetContent() is good enough, since the content of + // table pseudo-frames is the ancestor content. + RecreateFramesForContent(aFrame->GetContent(), true); + return true; + } + } + + // Now we have several cases involving {ib} splits. Put them all in a + // do/while with breaks to take us to the "go and reconstruct" code. + do { + if (IsInlineFrame(aFrame)) { + if (aItems.AreAllItemsInline()) { + // We can just put the kids in. + return false; + } + + if (!IsFramePartOfIBSplit(aFrame)) { + // Need to go ahead and reconstruct. + break; + } + + // Now we're adding kids including some blocks to an inline part of an + // {ib} split. If we plan to call AppendFrames, and don't have a next + // sibling for the new frames, and our parent is the last continuation of + // the last part of the {ib} split, and the same is true of all our + // ancestor inlines (they have no following continuations and they're the + // last part of their {ib} splits and we'd be adding to the end for all + // of them), then AppendFrames will handle things for us. Bail out in + // that case. + if (aIsAppend && IsSafeToAppendToIBSplitInline(aFrame, nextSibling)) { + return false; + } + + // Need to reconstruct. + break; + } + + // Now we know we have a block parent. If it's not part of an + // ib-split, we're all set. + if (!IsFramePartOfIBSplit(aFrame)) { + return false; + } + + // We're adding some kids to a block part of an {ib} split. If all the + // kids are blocks, we don't need to reconstruct. + if (aItems.AreAllItemsBlock()) { + return false; + } + + // We might have some inline kids for this block. Just reconstruct. + break; + } while (0); + + // If we don't have a containing block, start with aFrame and look for one. + if (!aContainingBlock) { + aContainingBlock = aFrame; + } + + // To find the right block to reframe, just walk up the tree until we find a + // frame that is: + // 1) Not part of an IB split + // 2) Not a pseudo-frame + // 3) Not an inline frame + // We're guaranteed to find one, since nsStyleContext::ApplyStyleFixups + // enforces that the root is display:none, display:table, or display:block. + // Note that walking up "too far" is OK in terms of correctness, even if it + // might be a little inefficient. This is why we walk out of all + // pseudo-frames -- telling which ones are or are not OK to walk out of is + // too hard (and I suspect that we do in fact need to walk out of all of + // them). + while (IsFramePartOfIBSplit(aContainingBlock) || + aContainingBlock->IsInlineOutside() || + aContainingBlock->StyleContext()->GetPseudo()) { + aContainingBlock = aContainingBlock->GetParent(); + NS_ASSERTION(aContainingBlock, + "Must have non-inline, non-ib-split, non-pseudo frame as " + "root (or child of root, for a table root)!"); + } + + // Tell parent of the containing block to reformulate the + // entire block. This is painful and definitely not optimal + // but it will *always* get the right answer. + + nsIContent *blockContent = aContainingBlock->GetContent(); +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::WipeContainingBlock: blockContent=%p\n", + static_cast(blockContent)); + } +#endif + RecreateFramesForContent(blockContent, true); + return true; +} + +nsresult +nsCSSFrameConstructor::ReframeContainingBlock(nsIFrame* aFrame) +{ + +#ifdef DEBUG + // ReframeContainingBlock is a NASTY routine, it causes terrible performance problems + // so I want to see when it is happening! Unfortunately, it is happening way to often because + // so much content on the web causes block-in-inline frame situations and we handle them + // very poorly + if (gNoisyContentUpdates) { + printf("nsCSSFrameConstructor::ReframeContainingBlock frame=%p\n", + static_cast(aFrame)); + } +#endif + + // XXXbz how exactly would we get here while isReflowing anyway? Should this + // whole test be ifdef DEBUG? + if (mPresShell->IsReflowLocked()) { + // don't ReframeContainingBlock, this will result in a crash + // if we remove a tree that's in reflow - see bug 121368 for testcase + NS_ERROR("Atemptted to nsCSSFrameConstructor::ReframeContainingBlock during a Reflow!!!"); + return NS_OK; + } + + // Get the first "normal" ancestor of the target frame. + nsIFrame* containingBlock = GetIBContainingBlockFor(aFrame); + if (containingBlock) { + // From here we look for the containing block in case the target + // frame is already a block (which can happen when an inline frame + // wraps some of its content in an anonymous block; see + // ConstructInline) + + // NOTE: We used to get the FloatContainingBlock here, but it was often wrong. + // GetIBContainingBlock works much better and provides the correct container in all cases + // so GetFloatContainingBlock(aFrame) has been removed + + // And get the containingBlock's content + nsCOMPtr blockContent = containingBlock->GetContent(); + if (blockContent) { +#ifdef DEBUG + if (gNoisyContentUpdates) { + printf(" ==> blockContent=%p\n", static_cast(blockContent)); + } +#endif + return RecreateFramesForContent(blockContent, true); + } + } + + // If we get here, we're screwed! + return RecreateFramesForContent(mPresShell->GetDocument()->GetRootElement(), + true); +} + +nsresult +nsCSSFrameConstructor::GenerateChildFrames(nsIFrame* aFrame) +{ + { + nsAutoScriptBlocker scriptBlocker; + BeginUpdate(); + + nsFrameItems childItems; + nsFrameConstructorState state(mPresShell, nullptr, nullptr, nullptr); + // We don't have a parent frame with a pending binding constructor here, + // so no need to worry about ordering of the kids' constructors with it. + // Pass null for the PendingBinding. + ProcessChildren(state, aFrame->GetContent(), aFrame->StyleContext(), + aFrame, false, childItems, false, + nullptr); + + aFrame->SetInitialChildList(kPrincipalList, childItems); + + EndUpdate(); + } + +#ifdef ACCESSIBILITY + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + nsIContent* container = aFrame->GetContent(); + nsIContent* child = container->GetFirstChild(); + if (child) { + accService->ContentRangeInserted(mPresShell, container, child, nullptr); + } + } +#endif + + // call XBL constructors after the frames are created + mPresShell->GetDocument()->BindingManager()->ProcessAttachedQueue(); + + return NS_OK; +} + +////////////////////////////////////////////////////////// +// nsCSSFrameConstructor::FrameConstructionItem methods // +////////////////////////////////////////////////////////// +bool +nsCSSFrameConstructor:: +FrameConstructionItem::IsWhitespace(nsFrameConstructorState& aState) const +{ + NS_PRECONDITION(aState.mCreatingExtraFrames || + !mContent->GetPrimaryFrame(), "How did that happen?"); + if (!mIsText) { + return false; + } + mContent->SetFlags(NS_CREATE_FRAME_IF_NON_WHITESPACE | + NS_REFRAME_IF_WHITESPACE); + return mContent->TextIsOnlyWhitespace(); +} + +////////////////////////////////////////////////////////////// +// nsCSSFrameConstructor::FrameConstructionItemList methods // +////////////////////////////////////////////////////////////// +void +nsCSSFrameConstructor::FrameConstructionItemList:: +AdjustCountsForItem(FrameConstructionItem* aItem, int32_t aDelta) +{ + NS_PRECONDITION(aDelta == 1 || aDelta == -1, "Unexpected delta"); + mItemCount += aDelta; + if (aItem->mIsAllInline) { + mInlineCount += aDelta; + } + if (aItem->mIsBlock) { + mBlockCount += aDelta; + } + if (aItem->mIsLineParticipant) { + mLineParticipantCount += aDelta; + } + mDesiredParentCounts[aItem->DesiredParentType()] += aDelta; +} + +//////////////////////////////////////////////////////////////////////// +// nsCSSFrameConstructor::FrameConstructionItemList::Iterator methods // +//////////////////////////////////////////////////////////////////////// +inline bool +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::SkipItemsWantingParentType(ParentType aParentType) +{ + NS_PRECONDITION(!IsDone(), "Shouldn't be done yet"); + while (item().DesiredParentType() == aParentType) { + Next(); + if (IsDone()) { + return true; + } + } + return false; +} + +bool +nsCSSFrameConstructor::FrameConstructionItem:: + NeedsAnonFlexItem(const nsFrameConstructorState& aState) +{ + if (mFCData->mBits & FCDATA_IS_LINE_PARTICIPANT) { + // This will be an inline non-replaced box. + return true; + } + + if (!(mFCData->mBits & FCDATA_DISALLOW_OUT_OF_FLOW) && + aState.GetGeometricParent(mStyleContext->StyleDisplay(), nullptr)) { + // We're abspos or fixedpos, which means we'll spawn a placeholder which + // we'll need to wrap in an anonymous flex item. So, we just treat + // _this_ frame as if _it_ needs to be wrapped in an anonymous flex item, + // and then when we spawn the placeholder, it'll end up in the right spot. + return true; + } + + return false; +} + +inline bool +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::SkipItemsThatNeedAnonFlexItem( + const nsFrameConstructorState& aState) +{ + NS_PRECONDITION(!IsDone(), "Shouldn't be done yet"); + while (item().NeedsAnonFlexItem(aState)) { + Next(); + if (IsDone()) { + return true; + } + } + return false; +} + +inline bool +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::SkipItemsThatDontNeedAnonFlexItem( + const nsFrameConstructorState& aState) +{ + NS_PRECONDITION(!IsDone(), "Shouldn't be done yet"); + while (!(item().NeedsAnonFlexItem(aState))) { + Next(); + if (IsDone()) { + return true; + } + } + return false; +} + +inline bool +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::SkipWhitespace(nsFrameConstructorState& aState) +{ + NS_PRECONDITION(!IsDone(), "Shouldn't be done yet"); + NS_PRECONDITION(item().IsWhitespace(aState), "Not pointing to whitespace?"); + do { + Next(); + if (IsDone()) { + return true; + } + } while (item().IsWhitespace(aState)); + + return false; +} + +void +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::AppendItemToList(FrameConstructionItemList& aTargetList) +{ + NS_ASSERTION(&aTargetList != &mList, "Unexpected call"); + NS_PRECONDITION(!IsDone(), "should not be done"); + + FrameConstructionItem* item = ToItem(mCurrent); + Next(); + PR_REMOVE_LINK(item); + PR_APPEND_LINK(item, &aTargetList.mItems); + + mList.AdjustCountsForItem(item, -1); + aTargetList.AdjustCountsForItem(item, 1); +} + +void +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::AppendItemsToList(const Iterator& aEnd, + FrameConstructionItemList& aTargetList) +{ + NS_ASSERTION(&aTargetList != &mList, "Unexpected call"); + NS_PRECONDITION(mEnd == aEnd.mEnd, "end iterator for some other list?"); + + // We can't just move our guts to the other list if it already has + // some information or if we're not moving our entire list. + if (!AtStart() || !aEnd.IsDone() || !aTargetList.IsEmpty() || + !aTargetList.mUndisplayedItems.IsEmpty()) { + do { + AppendItemToList(aTargetList); + } while (*this != aEnd); + return; + } + + // move over the list of items + PR_INSERT_AFTER(&aTargetList.mItems, &mList.mItems); + // Need to init when we remove to makd ~FrameConstructionItemList work right. + PR_REMOVE_AND_INIT_LINK(&mList.mItems); + + // Copy over the various counters + aTargetList.mInlineCount = mList.mInlineCount; + aTargetList.mBlockCount = mList.mBlockCount; + aTargetList.mLineParticipantCount = mList.mLineParticipantCount; + aTargetList.mItemCount = mList.mItemCount; + memcpy(aTargetList.mDesiredParentCounts, mList.mDesiredParentCounts, + sizeof(aTargetList.mDesiredParentCounts)); + + // Swap out undisplayed item arrays, before we nuke the array on our end + aTargetList.mUndisplayedItems.SwapElements(mList.mUndisplayedItems); + + // reset mList + mList.~FrameConstructionItemList(); + new (&mList) FrameConstructionItemList(); + + // Point ourselves to aEnd, as advertised + mCurrent = mEnd = &mList.mItems; + NS_POSTCONDITION(*this == aEnd, "How did that happen?"); +} + +void +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::InsertItem(FrameConstructionItem* aItem) +{ + // Just insert the item before us. There's no magic here. + PR_INSERT_BEFORE(aItem, mCurrent); + mList.AdjustCountsForItem(aItem, 1); + + NS_POSTCONDITION(PR_NEXT_LINK(aItem) == mCurrent, "How did that happen?"); +} + +void +nsCSSFrameConstructor::FrameConstructionItemList:: +Iterator::DeleteItemsTo(const Iterator& aEnd) +{ + NS_PRECONDITION(mEnd == aEnd.mEnd, "end iterator for some other list?"); + NS_PRECONDITION(*this != aEnd, "Shouldn't be at aEnd yet"); + + do { + NS_ASSERTION(!IsDone(), "Ran off end of list?"); + FrameConstructionItem* item = ToItem(mCurrent); + Next(); + PR_REMOVE_LINK(item); + mList.AdjustCountsForItem(item, -1); + delete item; + } while (*this != aEnd); +}