diff options
Diffstat (limited to 'layout/base/nsCSSFrameConstructor.h')
| -rw-r--r-- | layout/base/nsCSSFrameConstructor.h | 2136 |
1 files changed, 2136 insertions, 0 deletions
diff --git a/layout/base/nsCSSFrameConstructor.h b/layout/base/nsCSSFrameConstructor.h new file mode 100644 index 000000000..7d1b8d42f --- /dev/null +++ b/layout/base/nsCSSFrameConstructor.h @@ -0,0 +1,2136 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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 + */ + +#ifndef nsCSSFrameConstructor_h___ +#define nsCSSFrameConstructor_h___ + +#include "mozilla/Attributes.h" +#include "mozilla/LinkedList.h" +#include "mozilla/RestyleManagerBase.h" +#include "mozilla/RestyleManagerHandle.h" + +#include "nsCOMPtr.h" +#include "nsILayoutHistoryState.h" +#include "nsQuoteList.h" +#include "nsCounterManager.h" +#include "nsIAnonymousContentCreator.h" +#include "nsFrameManager.h" +#include "ScrollbarStyles.h" + +struct nsFrameItems; +class nsStyleContext; +struct nsStyleDisplay; +struct nsGenConInitializer; + +class nsContainerFrame; +class nsFirstLineFrame; +class nsICSSAnonBoxPseudo; +class nsIDocument; +class nsPageContentFrame; +struct PendingBinding; +class nsGenericDOMDataNode; + +class nsFrameConstructorState; + +namespace mozilla { + +namespace dom { + +class FlattenedChildIterator; + +} // namespace dom +} // namespace mozilla + +class nsCSSFrameConstructor : public nsFrameManager +{ +public: + typedef mozilla::CSSPseudoElementType CSSPseudoElementType; + typedef mozilla::dom::Element Element; + + friend class mozilla::RestyleManager; + friend class mozilla::RestyleManagerBase; + friend class mozilla::ServoRestyleManager; + + nsCSSFrameConstructor(nsIDocument* aDocument, nsIPresShell* aPresShell); + ~nsCSSFrameConstructor(void) { + NS_ASSERTION(mUpdateCount == 0, "Dying in the middle of our own update?"); + } + + // get the alternate text for a content node + static void GetAlternateTextFor(nsIContent* aContent, + nsIAtom* aTag, // content object's tag + nsXPIDLString& aAltText); + +private: + nsCSSFrameConstructor(const nsCSSFrameConstructor& aCopy) = delete; + nsCSSFrameConstructor& operator=(const nsCSSFrameConstructor& aCopy) = delete; + +public: + mozilla::RestyleManagerHandle RestyleManager() const + { return mPresShell->GetPresContext()->RestyleManager(); } + + nsIFrame* ConstructRootFrame(); + + nsresult ReconstructDocElementHierarchy(); + + // Create frames for content nodes that are marked as needing frames. This + // should be called before ProcessPendingRestyles. + // Note: It's the caller's responsibility to make sure to wrap a + // CreateNeededFrames call in a view update batch and a script blocker. + void CreateNeededFrames(); + +private: + void CreateNeededFrames(nsIContent* aContent); + + enum Operation { + CONTENTAPPEND, + CONTENTINSERT + }; + + // aChild is the child being inserted for inserts, and the first + // child being appended for appends. + bool MaybeConstructLazily(Operation aOperation, + nsIContent* aContainer, + nsIContent* aChild); + + // Issues a single ContentInserted for each child of aContainer in the range + // [aStartChild, aEndChild). + void IssueSingleInsertNofications(nsIContent* aContainer, + nsIContent* aStartChild, + nsIContent* aEndChild, + bool aAllowLazyConstruction); + + /** + * Data that represents an insertion point for some child content. + */ + struct InsertionPoint + { + InsertionPoint() + : mParentFrame(nullptr), mContainer(nullptr), mMultiple(false) {} + InsertionPoint(nsContainerFrame* aParentFrame, nsIContent* aContainer, + bool aMultiple = false) + : mParentFrame(aParentFrame), mContainer(aContainer), + mMultiple(aMultiple) {} + /** + * The parent frame to use if the inserted children needs to create + * frame(s). May be null, which signals that we shouldn't try to + * create frames for the inserted children; either because there are + * no parent frame or because there are multiple insertion points and + * we will call IssueSingleInsertNofications for each child instead. + * mContainer should not be used when mParentFrame is null. + */ + nsContainerFrame* mParentFrame; + /** + * The flattened tree parent for the inserted children. + * It's undefined if mParentFrame is null. + */ + nsIContent* mContainer; + /** + * If true then there are multiple insertion points, which means consumers + * should insert children individually into the node's flattened tree parent. + */ + bool mMultiple; + }; + /** + * Checks if the children of aContainer in the range [aStartChild, aEndChild) + * can be inserted/appended to one insertion point together. If so, returns + * that insertion point. If not, returns with InsertionPoint.mFrame == nullptr + * and issues single ContentInserted calls for each child. + * aEndChild = nullptr indicates that we are dealing with an append. + */ + InsertionPoint GetRangeInsertionPoint(nsIContent* aContainer, + nsIContent* aStartChild, + nsIContent* aEndChild, + bool aAllowLazyConstruction); + + // Returns true if parent was recreated due to frameset child, false otherwise. + bool MaybeRecreateForFrameset(nsIFrame* aParentFrame, + nsIContent* aStartChild, + nsIContent* aEndChild); + +public: + /** + * Lazy frame construction is controlled by the aAllowLazyConstruction bool + * parameter of nsCSSFrameConstructor::ContentAppended/Inserted. It is true + * for all inserts/appends as passed from the presshell, except for the + * insert of the root element, which is always non-lazy. Even if the + * aAllowLazyConstruction passed to ContentAppended/Inserted is true we still + * may not be able to construct lazily, so we call MaybeConstructLazily. + * MaybeConstructLazily does not allow lazy construction if any of the + * following are true: + * -we are in chrome + * -the container is in a native anonymous subtree + * -the container is XUL + * -is any of the appended/inserted nodes are XUL or editable + * -(for inserts) the child is anonymous. In the append case this function + * must not be called with anonymous children. + * The XUL and chrome checks are because XBL bindings only get applied at + * frame construction time and some things depend on the bindings getting + * attached synchronously. The editable checks are because the editor seems + * to expect frames to be constructed synchronously. + * + * If MaybeConstructLazily returns false we construct as usual, but if it + * returns true then it adds NODE_NEEDS_FRAME bits to the newly + * inserted/appended nodes and adds NODE_DESCENDANTS_NEED_FRAMES bits to the + * container and up along the parent chain until it hits the root or another + * node with that bit set. Then it posts a restyle event to ensure that a + * flush happens to construct those frames. + * + * When the flush happens the presshell calls + * nsCSSFrameConstructor::CreateNeededFrames. CreateNeededFrames follows any + * nodes with NODE_DESCENDANTS_NEED_FRAMES set down the content tree looking + * for nodes with NODE_NEEDS_FRAME set. It calls ContentAppended for any runs + * of nodes with NODE_NEEDS_FRAME set that are at the end of their childlist, + * and ContentRangeInserted for any other runs that aren't. + * + * If a node is removed from the document then we don't bother unsetting any + * of the lazy bits that might be set on it, its descendants, or any of its + * ancestor nodes because that is a slow operation, the work might be wasted + * if another node gets inserted in its place, and we can clear the bits + * quicker by processing the content tree from top down the next time we call + * CreateNeededFrames. (We do clear the bits when BindToTree is called on any + * nsIContent; so any nodes added to the document will not have any lazy bits + * set.) + */ + + // If aAllowLazyConstruction is true then frame construction of the new + // children can be done lazily. + nsresult ContentAppended(nsIContent* aContainer, + nsIContent* aFirstNewContent, + bool aAllowLazyConstruction); + + // If aAllowLazyConstruction is true then frame construction of the new child + // can be done lazily. + nsresult ContentInserted(nsIContent* aContainer, + nsIContent* aChild, + nsILayoutHistoryState* aFrameState, + bool aAllowLazyConstruction); + + // Like ContentInserted but handles inserting the children of aContainer in + // the range [aStartChild, aEndChild). aStartChild must be non-null. + // aEndChild may be null to indicate the range includes all kids after + // aStartChild. If aAllowLazyConstruction is true then frame construction of + // the new children can be done lazily. It is only allowed to be true when + // inserting a single node. + nsresult ContentRangeInserted(nsIContent* aContainer, + nsIContent* aStartChild, + nsIContent* aEndChild, + nsILayoutHistoryState* aFrameState, + bool aAllowLazyConstruction); + + enum RemoveFlags { + REMOVE_CONTENT, REMOVE_FOR_RECONSTRUCTION, REMOVE_DESTROY_FRAMES }; + /** + * Recreate or destroy frames for aChild in aContainer. + * aFlags == REMOVE_CONTENT means aChild has been removed from the document. + * aFlags == REMOVE_FOR_RECONSTRUCTION means the caller will reconstruct the + * frames later. + * In both the above cases, this method will in some cases try to reconstruct + * the frames (aDidReconstruct is then set to true), it's just that in the + * former case aChild isn't in the document so no frames will be created for + * it. Ancestors may have been reframed though. + * aFlags == REMOVE_DESTROY_FRAMES is the same as REMOVE_FOR_RECONSTRUCTION + * except it will never try to reconstruct frames. Instead, the caller is + * responsible for doing that, on the content returned in aDestroyedFramesFor. + * The layout frame state is guarranted to be captured for the removed frames + * only when aFlags == REMOVE_DESTROY_FRAMES, otherwise it will only be + * captured if we reconstructed frames for an ancestor. + */ + nsresult ContentRemoved(nsIContent* aContainer, + nsIContent* aChild, + nsIContent* aOldNextSibling, + RemoveFlags aFlags, + bool* aDidReconstruct, + nsIContent** aDestroyedFramesFor = nullptr); + + nsresult CharacterDataChanged(nsIContent* aContent, + CharacterDataChangeInfo* aInfo); + + // If aContent is a text node that has been optimized away due to being + // whitespace next to a block boundary (or for some other reason), stop + // doing that and create a frame for it if it should have one. This recreates + // frames so be careful (although this should not change actual layout). + // Returns the frame for aContent if there is one. + nsIFrame* EnsureFrameForTextNode(nsGenericDOMDataNode* aContent); + + // generate the child frames and process bindings + nsresult GenerateChildFrames(nsContainerFrame* aFrame); + + // Should be called when a frame is going to be destroyed and + // WillDestroyFrameTree hasn't been called yet. + void NotifyDestroyingFrame(nsIFrame* aFrame); + + void BeginUpdate(); + void EndUpdate(); + void RecalcQuotesAndCounters(); + + // Called when any counter style is changed. + void NotifyCounterStylesAreDirty(); + + // Gets called when the presshell is destroying itself and also + // when we tear down our frame tree to reconstruct it + void WillDestroyFrameTree(); + + /** + * Destroy the frames for aContent. Note that this may destroy frames + * for an ancestor instead - aDestroyedFramesFor contains the content node + * where frames were actually destroyed (which should be used in the + * ContentInserted call to recreate frames). The frame tree state + * is captured before the frames are destroyed and can be retrieved using + * GetLastCapturedLayoutHistoryState(). + */ + void DestroyFramesFor(nsIContent* aContent, + nsIContent** aDestroyedFramesFor); + + // Request to create a continuing frame. This method never returns null. + nsIFrame* CreateContinuingFrame(nsPresContext* aPresContext, + nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + bool aIsFluid = true); + + // Copy over fixed frames from aParentFrame's prev-in-flow + nsresult ReplicateFixedFrames(nsPageContentFrame* aParentFrame); + + /** + * Get the XBL insertion point for aChild in aContainer. + */ + InsertionPoint GetInsertionPoint(nsIContent* aContainer, nsIContent* aChild); + + nsresult CreateListBoxContent(nsContainerFrame* aParentFrame, + nsIFrame* aPrevFrame, + nsIContent* aChild, + nsIFrame** aResult, + bool aIsAppend); + + // GetInitialContainingBlock() is deprecated in favor of GetRootElementFrame(); + // nsIFrame* GetInitialContainingBlock() { return mRootElementFrame; } + // This returns the outermost frame for the root element + nsContainerFrame* GetRootElementFrame() { return mRootElementFrame; } + // This returns the frame for the root element that does not + // have a psuedo-element style + nsIFrame* GetRootElementStyleFrame() { return mRootElementStyleFrame; } + nsIFrame* GetPageSequenceFrame() { return mPageSequenceFrame; } + + // Get the frame that is the parent of the root element. + nsContainerFrame* GetDocElementContainingBlock() + { return mDocElementContainingBlock; } + + /** + * Return the layout history state that was captured in the last + * ContentRemoved / RecreateFramesForContent call. + */ + nsILayoutHistoryState* GetLastCapturedLayoutHistoryState() + { + return mTempFrameTreeState; + } + +private: + struct FrameConstructionItem; + class FrameConstructionItemList; + + nsContainerFrame* ConstructPageFrame(nsIPresShell* aPresShell, + nsContainerFrame* aParentFrame, + nsIFrame* aPrevPageFrame, + nsContainerFrame*& aCanvasFrame); + + void InitAndRestoreFrame (const nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsIFrame* aNewFrame, + bool aAllowCounters = true); + + // aState can be null if not available; it's used as an optimization. + // XXXbz IsValidSibling is the only caller that doesn't pass a state here! + already_AddRefed<nsStyleContext> + ResolveStyleContext(nsIFrame* aParentFrame, + nsIContent* aContainer, + nsIContent* aChild, + nsFrameConstructorState* aState); + already_AddRefed<nsStyleContext> + ResolveStyleContext(nsIFrame* aParentFrame, + nsIContent* aChild, + nsFrameConstructorState* aState); + already_AddRefed<nsStyleContext> + ResolveStyleContext(const InsertionPoint& aInsertion, + nsIContent* aChild, + nsFrameConstructorState* aState); + already_AddRefed<nsStyleContext> + ResolveStyleContext(nsStyleContext* aParentStyleContext, + nsIContent* aContent, + nsFrameConstructorState* aState); + + // Add the frame construction items for the given aContent and aParentFrame + // to the list. This might add more than one item in some rare cases. + // If aSuppressWhiteSpaceOptimizations is true, optimizations that + // may suppress the construction of white-space-only text frames + // must be skipped for these items and items around them. + void AddFrameConstructionItems(nsFrameConstructorState& aState, + nsIContent* aContent, + bool aSuppressWhiteSpaceOptimizations, + const InsertionPoint& aInsertion, + FrameConstructionItemList& aItems); + + // Helper method for AddFrameConstructionItems etc. + // Unsets the need-frame/restyle bits on aContent. + // return true iff we should attempt to create frames for aContent. + bool ShouldCreateItemsForChild(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame); + + // Helper method for AddFrameConstructionItems etc. + // Make sure ShouldCreateItemsForChild() returned true before calling this. + void DoAddFrameConstructionItems(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aStyleContext, + bool aSuppressWhiteSpaceOptimizations, + nsContainerFrame* aParentFrame, + nsTArray<nsIAnonymousContentCreator::ContentInfo>* aAnonChildren, + FrameConstructionItemList& aItems); + + // Construct the frames for the document element. This can return null if the + // document element is display:none, or if the document element has a + // not-yet-loaded XBL binding, or if it's an SVG element that's not <svg>. + nsIFrame* ConstructDocElementFrame(Element* aDocElement, + nsILayoutHistoryState* aFrameState); + + // Set up our mDocElementContainingBlock correctly for the given root + // content. + void SetUpDocElementContainingBlock(nsIContent* aDocElement); + + /** + * CreateAttributeContent creates a single content/frame combination for an + * |attr(foo)| generated content. + * + * @param aParentContent the parent content for the generated content + * @param aParentFrame the parent frame for the generated frame + * @param aAttrNamespace the namespace of the attribute in question + * @param aAttrName the localname of the attribute + * @param aStyleContext the style context to use + * @param aGeneratedContent the array of generated content to append the + * created content to. + * @param [out] aNewContent the content node we create + * @param [out] aNewFrame the new frame we create + */ + nsresult CreateAttributeContent(nsIContent* aParentContent, + nsIFrame* aParentFrame, + int32_t aAttrNamespace, + nsIAtom* aAttrName, + nsStyleContext* aStyleContext, + nsCOMArray<nsIContent>& aGeneratedContent, + nsIContent** aNewContent, + nsIFrame** aNewFrame); + + /** + * Create a text node containing the given string. If aText is non-null + * then we also set aText to the returned node. + */ + already_AddRefed<nsIContent> CreateGenConTextNode(nsFrameConstructorState& aState, + const nsString& aString, + RefPtr<nsTextNode>* aText, + nsGenConInitializer* aInitializer); + + /** + * Create a content node for the given generated content style. + * The caller takes care of making it SetIsNativeAnonymousRoot, binding it + * to the document, and creating frames for it. + * @param aParentContent is the node that has the before/after style + * @param aStyleContext is the 'before' or 'after' pseudo-element + * style context + * @param aContentIndex is the index of the content item to create + */ + already_AddRefed<nsIContent> CreateGeneratedContent(nsFrameConstructorState& aState, + nsIContent* aParentContent, + nsStyleContext* aStyleContext, + uint32_t aContentIndex); + + // aFrame may be null; this method doesn't use it directly in any case. + void CreateGeneratedContentItem(nsFrameConstructorState& aState, + nsContainerFrame* aFrame, + nsIContent* aContent, + nsStyleContext* aStyleContext, + CSSPseudoElementType aPseudoElement, + FrameConstructionItemList& aItems); + + // This method can change aFrameList: it can chop off the beginning and put + // it in aParentFrame while putting the remainder into a ib-split sibling of + // aParentFrame. aPrevSibling must be the frame after which aFrameList is to + // be placed on aParentFrame's principal child list. It may be null if + // aFrameList is being added at the beginning of the child list. + nsresult AppendFramesToParent(nsFrameConstructorState& aState, + nsContainerFrame* aParentFrame, + nsFrameItems& aFrameList, + nsIFrame* aPrevSibling, + bool aIsRecursiveCall = false); + + // BEGIN TABLE SECTION + /** + * Construct a table wrapper frame. This is the FrameConstructionData + * callback used for the job. + */ + nsIFrame* ConstructTable(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems); + + /** + * FrameConstructionData callback for constructing table rows and row groups. + */ + nsIFrame* ConstructTableRowOrRowGroup(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + + /** + * FrameConstructionData callback used for constructing table columns. + */ + nsIFrame* ConstructTableCol(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + + /** + * FrameConstructionData callback used for constructing table cells. + */ + nsIFrame* ConstructTableCell(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + +private: + /* An enum of possible parent types for anonymous table or ruby object + construction */ + enum ParentType { + eTypeBlock = 0, /* This includes all non-table-related frames */ + eTypeRow, + eTypeRowGroup, + eTypeColGroup, + eTypeTable, + eTypeRuby, + eTypeRubyBase, + eTypeRubyBaseContainer, + eTypeRubyText, + eTypeRubyTextContainer, + eParentTypeCount + }; + + /* 4 bits is enough to handle our ParentType values */ +#define FCDATA_PARENT_TYPE_OFFSET 28 + /* Macro to get the desired parent type out of an mBits member of + FrameConstructionData */ +#define FCDATA_DESIRED_PARENT_TYPE(_bits) \ + ParentType((_bits) >> FCDATA_PARENT_TYPE_OFFSET) + /* Macro to create FrameConstructionData bits out of a desired parent type */ +#define FCDATA_DESIRED_PARENT_TYPE_TO_BITS(_type) \ + (((uint32_t)(_type)) << FCDATA_PARENT_TYPE_OFFSET) + + /* Get the parent type that aParentFrame has. */ + static ParentType GetParentType(nsIFrame* aParentFrame) { + return GetParentType(aParentFrame->GetType()); + } + + /* Get the parent type for the given nsIFrame type atom */ + static ParentType GetParentType(nsIAtom* aFrameType); + + static bool IsRubyParentType(ParentType aParentType) { + return (aParentType == eTypeRuby || + aParentType == eTypeRubyBase || + aParentType == eTypeRubyBaseContainer || + aParentType == eTypeRubyText || + aParentType == eTypeRubyTextContainer); + } + + static bool IsTableParentType(ParentType aParentType) { + return (aParentType == eTypeTable || + aParentType == eTypeRow || + aParentType == eTypeRowGroup || + aParentType == eTypeColGroup); + } + + /* A constructor function that just creates an nsIFrame object. The caller + is responsible for initializing the object, adding it to frame lists, + constructing frames for the children, etc. + + @param nsIPresShell the presshell whose arena should be used to allocate + the frame. + @param nsStyleContext the style context to use for the frame. */ + typedef nsIFrame* (* FrameCreationFunc)(nsIPresShell*, nsStyleContext*); + typedef nsContainerFrame* (* ContainerFrameCreationFunc)(nsIPresShell*, nsStyleContext*); + typedef nsBlockFrame* (* BlockFrameCreationFunc)(nsIPresShell*, nsStyleContext*); + + /* A function that can be used to get a FrameConstructionData. Such + a function is allowed to return null. + + @param nsIContent the node for which the frame is being constructed. + @param nsStyleContext the style context to be used for the frame. + */ + struct FrameConstructionData; + typedef const FrameConstructionData* + (* FrameConstructionDataGetter)(Element*, nsStyleContext*); + + /* A constructor function that's used for complicated construction tasks. + This is expected to create the new frame, initialize it, add whatever + needs to be added to aFrameItems (XXXbz is that really necessary? Could + caller add? Might there be cases when the returned frame or its + placeholder is not the thing that ends up in aFrameItems? If not, would + it be safe to do the add into the frame construction state after + processing kids? Look into this as a followup!), process children as + needed, etc. It is NOT expected to deal with setting the frame on the + content. + + @param aState the frame construction state to use. + @param aItem the frame construction item to use + @param aParentFrame the frame to set as the parent of the + newly-constructed frame. + @param aStyleDisplay the display struct from aItem's mStyleContext + @param aFrameItems the frame list to add the new frame (or its + placeholder) to. + @return the frame that was constructed. This frame is what the caller + will set as the frame on the content. Guaranteed non-null. + */ + typedef nsIFrame* + (nsCSSFrameConstructor::* FrameFullConstructor)(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + + /* Bits that modify the way a FrameConstructionData is handled */ + + /* If the FCDATA_SKIP_FRAMESET bit is set, then the frame created should not + be set as the primary frame on the content node. This should only be used + in very rare cases when we create more than one frame for a given content + node. */ +#define FCDATA_SKIP_FRAMESET 0x1 + /* If the FCDATA_FUNC_IS_DATA_GETTER bit is set, then the mFunc of the + FrameConstructionData is a getter function that can be used to get the + actual FrameConstructionData to use. */ +#define FCDATA_FUNC_IS_DATA_GETTER 0x2 + /* If the FCDATA_FUNC_IS_FULL_CTOR bit is set, then the FrameConstructionData + has an mFullConstructor. In this case, there is no relevant mData or + mFunc */ +#define FCDATA_FUNC_IS_FULL_CTOR 0x4 + /* If FCDATA_DISALLOW_OUT_OF_FLOW is set, do not allow the frame to + float or be absolutely positioned. This can also be used with + FCDATA_FUNC_IS_FULL_CTOR to indicate what the full-constructor + function will do. */ +#define FCDATA_DISALLOW_OUT_OF_FLOW 0x8 + /* If FCDATA_FORCE_NULL_ABSPOS_CONTAINER is set, make sure to push a + null absolute containing block before processing children for this + frame. If this is not set, the frame will be pushed as the + absolute containing block as needed, based on its style */ +#define FCDATA_FORCE_NULL_ABSPOS_CONTAINER 0x10 + /* If FCDATA_WRAP_KIDS_IN_BLOCKS is set, the inline kids of the frame + will be wrapped in blocks. This is only usable for MathML at the + moment. */ +#define FCDATA_WRAP_KIDS_IN_BLOCKS 0x20 + /* If FCDATA_SUPPRESS_FRAME is set, no frame should be created for the + content. If this bit is set, nothing else in the struct needs to be + set. */ +#define FCDATA_SUPPRESS_FRAME 0x40 + /* If FCDATA_MAY_NEED_SCROLLFRAME is set, the new frame should be wrapped in + a scrollframe if its overflow type so requires. */ +#define FCDATA_MAY_NEED_SCROLLFRAME 0x80 +#ifdef MOZ_XUL + /* If FCDATA_IS_POPUP is set, the new frame is a XUL popup frame. These need + some really weird special handling. */ +#define FCDATA_IS_POPUP 0x100 +#endif /* MOZ_XUL */ + /* If FCDATA_SKIP_ABSPOS_PUSH is set, don't push this frame as an + absolute containing block, no matter what its style says. */ +#define FCDATA_SKIP_ABSPOS_PUSH 0x200 + /* If FCDATA_DISALLOW_GENERATED_CONTENT is set, then don't allow generated + content when processing kids of this frame. This should not be used with + FCDATA_FUNC_IS_FULL_CTOR */ +#define FCDATA_DISALLOW_GENERATED_CONTENT 0x400 + /* If FCDATA_IS_TABLE_PART is set, then the frame is some sort of + table-related thing and we should not attempt to fetch a table-cell parent + for it if it's inside another table-related frame. */ +#define FCDATA_IS_TABLE_PART 0x800 + /* If FCDATA_IS_INLINE is set, then the frame is a non-replaced CSS + inline box. */ +#define FCDATA_IS_INLINE 0x1000 + /* If FCDATA_IS_LINE_PARTICIPANT is set, the frame is something that will + return true for IsFrameOfType(nsIFrame::eLineParticipant) */ +#define FCDATA_IS_LINE_PARTICIPANT 0x2000 + /* If FCDATA_IS_LINE_BREAK is set, the frame is something that will + induce a line break boundary before and after itself. */ +#define FCDATA_IS_LINE_BREAK 0x4000 + /* If FCDATA_ALLOW_BLOCK_STYLES is set, allow block styles when processing + children. This should not be used with FCDATA_FUNC_IS_FULL_CTOR. */ +#define FCDATA_ALLOW_BLOCK_STYLES 0x8000 + /* If FCDATA_USE_CHILD_ITEMS is set, then use the mChildItems in the relevant + FrameConstructionItem instead of trying to process the content's children. + This can be used with or without FCDATA_FUNC_IS_FULL_CTOR. + The child items might still need table pseudo processing. */ +#define FCDATA_USE_CHILD_ITEMS 0x10000 + /* If FCDATA_FORCED_NON_SCROLLABLE_BLOCK is set, then this block + would have been scrollable but has been forced to be + non-scrollable due to being in a paginated context. */ +#define FCDATA_FORCED_NON_SCROLLABLE_BLOCK 0x20000 + /* If FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS is set, then create a + block formatting context wrapper around the kids of this frame + using the FrameConstructionData's mPseudoAtom for its anonymous + box type. */ +#define FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS 0x40000 + /* If FCDATA_IS_SVG_TEXT is set, then this text frame is a descendant of + an SVG text frame. */ +#define FCDATA_IS_SVG_TEXT 0x80000 + /** + * display:contents + */ +#define FCDATA_IS_CONTENTS 0x100000 + /** + * When FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS is set, this bit says + * if we should create a grid/flex/columnset container instead of + * a block wrapper when the styles says so. + */ +#define FCDATA_ALLOW_GRID_FLEX_COLUMNSET 0x200000 + + /* Structure representing information about how a frame should be + constructed. */ + struct FrameConstructionData { + // Flag bits that can modify the way the construction happens + uint32_t mBits; + // We have exactly one of three types of functions, so use a union for + // better cache locality for the ones that aren't pointer-to-member. That + // one needs to be separate, because we can't cast between it and the + // others and hence wouldn't be able to initialize the union without a + // constructor and all the resulting generated code. See documentation + // above for FrameCreationFunc, FrameConstructionDataGetter, and + // FrameFullConstructor to see what the functions would do. + union Func { + FrameCreationFunc mCreationFunc; + FrameConstructionDataGetter mDataGetter; + } mFunc; + FrameFullConstructor mFullConstructor; + // For cases when FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS is set, the + // anonymous box type to use for that wrapper. + nsICSSAnonBoxPseudo * const * const mAnonBoxPseudo; + }; + + /* Structure representing a mapping of an atom to a FrameConstructionData. + This can be used with non-static atoms, assuming that the nsIAtom* is + stored somewhere that this struct can point to (that is, a static + nsIAtom*) and that it's allocated before the struct is ever used. */ + struct FrameConstructionDataByTag { + // Pointer to nsIAtom* is used because we want to initialize this + // statically, so before our atom tables are set up. + const nsIAtom * const * const mTag; + const FrameConstructionData mData; + }; + + /* Structure representing a mapping of an integer to a + FrameConstructionData. There are no magic integer values here. */ + struct FrameConstructionDataByInt { + /* Could be used for display or whatever else */ + const int32_t mInt; + const FrameConstructionData mData; + }; + + struct FrameConstructionDataByDisplay { +#ifdef DEBUG + const mozilla::StyleDisplay mDisplay; +#endif + const FrameConstructionData mData; + }; + +#ifdef DEBUG +#define FCDATA_FOR_DISPLAY(_display, _fcdata) \ + { _display, _fcdata } +#else +#define FCDATA_FOR_DISPLAY(_display, _fcdata) \ + { _fcdata } +#endif + + /* Structure that has a FrameConstructionData and style context pseudo-type + for a table pseudo-frame */ + struct PseudoParentData { + const FrameConstructionData mFCData; + nsICSSAnonBoxPseudo * const * const mPseudoType; + }; + /* Array of such structures that we use to properly construct table + pseudo-frames as needed */ + static const PseudoParentData sPseudoParentData[eParentTypeCount]; + + /* A function that takes an integer, content, style context, and array of + FrameConstructionDataByInts and finds the appropriate frame construction + data to use and returns it. This can return null if none of the integers + match or if the matching integer has a FrameConstructionDataGetter that + returns null. */ + static const FrameConstructionData* + FindDataByInt(int32_t aInt, Element* aElement, + nsStyleContext* aStyleContext, + const FrameConstructionDataByInt* aDataPtr, + uint32_t aDataLength); + + /* A function that takes a tag, content, style context, and array of + FrameConstructionDataByTags and finds the appropriate frame construction + data to use and returns it. This can return null if none of the tags + match or if the matching tag has a FrameConstructionDataGetter that + returns null. */ + static const FrameConstructionData* + FindDataByTag(nsIAtom* aTag, Element* aElement, + nsStyleContext* aStyleContext, + const FrameConstructionDataByTag* aDataPtr, + uint32_t aDataLength); + + /* A class representing a list of FrameConstructionItems */ + class FrameConstructionItemList final { + public: + FrameConstructionItemList() : + mInlineCount(0), + mBlockCount(0), + mLineParticipantCount(0), + mItemCount(0), + mLineBoundaryAtStart(false), + mLineBoundaryAtEnd(false), + mParentHasNoXBLChildren(false), + mTriedConstructingFrames(false) + { + memset(mDesiredParentCounts, 0, sizeof(mDesiredParentCounts)); + } + + ~FrameConstructionItemList() { + while (FrameConstructionItem* item = mItems.popFirst()) { + delete item; + } + + // Create the undisplayed entries for our mUndisplayedItems, if any, but + // only if we have tried constructing frames for this item list. If we + // haven't, then we're just throwing it away and will probably try again. + if (!mUndisplayedItems.IsEmpty() && mTriedConstructingFrames) { + // We could store the frame manager in a member, but just + // getting it off the style context is not too bad. + nsFrameManager *mgr = + mUndisplayedItems[0].mStyleContext->PresContext()->FrameManager(); + for (uint32_t i = 0; i < mUndisplayedItems.Length(); ++i) { + UndisplayedItem& item = mUndisplayedItems[i]; + mgr->SetUndisplayedContent(item.mContent, item.mStyleContext); + } + } + } + + void SetLineBoundaryAtStart(bool aBoundary) { mLineBoundaryAtStart = aBoundary; } + void SetLineBoundaryAtEnd(bool aBoundary) { mLineBoundaryAtEnd = aBoundary; } + void SetParentHasNoXBLChildren(bool aHasNoXBLChildren) { + mParentHasNoXBLChildren = aHasNoXBLChildren; + } + void SetTriedConstructingFrames() { mTriedConstructingFrames = true; } + bool HasLineBoundaryAtStart() { return mLineBoundaryAtStart; } + bool HasLineBoundaryAtEnd() { return mLineBoundaryAtEnd; } + bool ParentHasNoXBLChildren() { return mParentHasNoXBLChildren; } + bool IsEmpty() const { return mItems.isEmpty(); } + bool AnyItemsNeedBlockParent() const { return mLineParticipantCount != 0; } + bool AreAllItemsInline() const { return mInlineCount == mItemCount; } + bool AreAllItemsBlock() const { return mBlockCount == mItemCount; } + bool AllWantParentType(ParentType aDesiredParentType) const { + return mDesiredParentCounts[aDesiredParentType] == mItemCount; + } + + // aSuppressWhiteSpaceOptimizations is true if optimizations that + // skip constructing whitespace frames for this item or items + // around it cannot be performed. + // Also, the return value is always non-null, thanks to infallible 'new'. + FrameConstructionItem* AppendItem(const FrameConstructionData* aFCData, + nsIContent* aContent, + nsIAtom* aTag, + int32_t aNameSpaceID, + PendingBinding* aPendingBinding, + already_AddRefed<nsStyleContext>&& aStyleContext, + bool aSuppressWhiteSpaceOptimizations, + nsTArray<nsIAnonymousContentCreator::ContentInfo>* aAnonChildren) + { + FrameConstructionItem* item = + new FrameConstructionItem(aFCData, aContent, aTag, aNameSpaceID, + aPendingBinding, aStyleContext, + aSuppressWhiteSpaceOptimizations, + aAnonChildren); + mItems.insertBack(item); + ++mItemCount; + ++mDesiredParentCounts[item->DesiredParentType()]; + return item; + } + + // Arguments are the same as AppendItem(). + FrameConstructionItem* PrependItem(const FrameConstructionData* aFCData, + nsIContent* aContent, + nsIAtom* aTag, + int32_t aNameSpaceID, + PendingBinding* aPendingBinding, + already_AddRefed<nsStyleContext>&& aStyleContext, + bool aSuppressWhiteSpaceOptimizations, + nsTArray<nsIAnonymousContentCreator::ContentInfo>* aAnonChildren) + { + FrameConstructionItem* item = + new FrameConstructionItem(aFCData, aContent, aTag, aNameSpaceID, + aPendingBinding, aStyleContext, + aSuppressWhiteSpaceOptimizations, + aAnonChildren); + mItems.insertFront(item); + ++mItemCount; + ++mDesiredParentCounts[item->DesiredParentType()]; + return item; + } + + void AppendUndisplayedItem(nsIContent* aContent, + nsStyleContext* aStyleContext) { + mUndisplayedItems.AppendElement(UndisplayedItem(aContent, aStyleContext)); + } + + void InlineItemAdded() { ++mInlineCount; } + void BlockItemAdded() { ++mBlockCount; } + void LineParticipantItemAdded() { ++mLineParticipantCount; } + + class Iterator { + public: + explicit Iterator(FrameConstructionItemList& aList) + : mCurrent(aList.mItems.getFirst()) + , mList(aList) + {} + Iterator(const Iterator& aOther) : + mCurrent(aOther.mCurrent), + mList(aOther.mList) + {} + + bool operator==(const Iterator& aOther) const { + MOZ_ASSERT(&mList == &aOther.mList, "Iterators for different lists?"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const Iterator& aOther) const { + return !(*this == aOther); + } + Iterator& operator=(const Iterator& aOther) { + MOZ_ASSERT(&mList == &aOther.mList, "Iterators for different lists?"); + mCurrent = aOther.mCurrent; + return *this; + } + + FrameConstructionItemList* List() { + return &mList; + } + + FrameConstructionItem& item() { + MOZ_ASSERT(!IsDone(), "Should have checked IsDone()!"); + return *mCurrent; + } + + const FrameConstructionItem& item() const { + MOZ_ASSERT(!IsDone(), "Should have checked IsDone()!"); + return *mCurrent; + } + + bool IsDone() const { return mCurrent == nullptr; } + bool AtStart() const { return mCurrent == mList.mItems.getFirst(); } + void Next() { + NS_ASSERTION(!IsDone(), "Should have checked IsDone()!"); + mCurrent = mCurrent->getNext(); + } + void Prev() { + NS_ASSERTION(!AtStart(), "Should have checked AtStart()!"); + mCurrent = mCurrent ? mCurrent->getPrevious() : mList.mItems.getLast(); + } + void SetToEnd() { mCurrent = nullptr; } + + // Skip over all items that want the given parent type. Return whether + // the iterator is done after doing that. The iterator must not be done + // when this is called. + inline bool SkipItemsWantingParentType(ParentType aParentType); + + // Skip over all items that want a parent type different from the given + // one. Return whether the iterator is done after doing that. The + // iterator must not be done when this is called. + inline bool SkipItemsNotWantingParentType(ParentType aParentType); + + // Skip over non-replaced inline frames and positioned frames. + // Return whether the iterator is done after doing that. + // The iterator must not be done when this is called. + inline bool SkipItemsThatNeedAnonFlexOrGridItem( + const nsFrameConstructorState& aState, + bool aIsWebkitBox); + + // Skip to the first frame that is a non-replaced inline or is + // positioned. Return whether the iterator is done after doing that. + // The iterator must not be done when this is called. + inline bool SkipItemsThatDontNeedAnonFlexOrGridItem( + const nsFrameConstructorState& aState, + bool aIsWebkitBox); + + // Skip over all items that do not want a ruby parent. Return whether + // the iterator is done after doing that. The iterator must not be done + // when this is called. + inline bool SkipItemsNotWantingRubyParent(); + + // Skip over whitespace. Return whether the iterator is done after doing + // that. The iterator must not be done, and must be pointing to a + // whitespace item when this is called. + inline bool SkipWhitespace(nsFrameConstructorState& aState); + + // Remove the item pointed to by this iterator from its current list and + // Append it to aTargetList. This iterator is advanced to point to the + // next item in its list. aIter must not be done. aTargetList must not be + // the list this iterator is iterating over.. + void AppendItemToList(FrameConstructionItemList& aTargetList); + + // As above, but moves all items starting with this iterator until we + // get to aEnd; the item pointed to by aEnd is not stolen. This method + // might have optimizations over just looping and doing StealItem for + // some special cases. After this method returns, this iterator will + // point to the item aEnd points to now; aEnd is not modified. + // aTargetList must not be the list this iterator is iterating over. + void AppendItemsToList(const Iterator& aEnd, + FrameConstructionItemList& aTargetList); + + // Insert aItem in this iterator's list right before the item pointed to + // by this iterator. After the insertion, this iterator will continue to + // point to the item it now points to (the one just after the + // newly-inserted item). This iterator is allowed to be done; in that + // case this call just appends the given item to the list. + void InsertItem(FrameConstructionItem* aItem); + + // Delete the items between this iterator and aEnd, including the item + // this iterator currently points to but not including the item pointed + // to by aEnd. When this returns, this iterator will point to the same + // item as aEnd. This iterator must not equal aEnd when this method is + // called. + void DeleteItemsTo(const Iterator& aEnd); + + private: + FrameConstructionItem* mCurrent; + FrameConstructionItemList& mList; + }; + + private: + struct UndisplayedItem { + UndisplayedItem(nsIContent* aContent, nsStyleContext* aStyleContext) : + mContent(aContent), mStyleContext(aStyleContext) + {} + + nsIContent * const mContent; + RefPtr<nsStyleContext> mStyleContext; + }; + + // Adjust our various counts for aItem being added or removed. aDelta + // should be either +1 or -1 depending on which is happening. + void AdjustCountsForItem(FrameConstructionItem* aItem, int32_t aDelta); + + mozilla::LinkedList<FrameConstructionItem> mItems; + uint32_t mInlineCount; + uint32_t mBlockCount; + uint32_t mLineParticipantCount; + uint32_t mItemCount; + uint32_t mDesiredParentCounts[eParentTypeCount]; + // True if there is guaranteed to be a line boundary before the + // frames created by these items + bool mLineBoundaryAtStart; + // True if there is guaranteed to be a line boundary after the + // frames created by these items + bool mLineBoundaryAtEnd; + // True if the parent is guaranteed to have no XBL anonymous children + bool mParentHasNoXBLChildren; + // True if we have tried constructing frames from this list + bool mTriedConstructingFrames; + + nsTArray<UndisplayedItem> mUndisplayedItems; + }; + + typedef FrameConstructionItemList::Iterator FCItemIterator; + + /* A struct representing an item for which frames might need to be + * constructed. This contains all the information needed to construct the + * frame other than the parent frame and whatever would be stored in the + * frame constructor state. */ + struct FrameConstructionItem final + : public mozilla::LinkedListElement<FrameConstructionItem> { + FrameConstructionItem(const FrameConstructionData* aFCData, + nsIContent* aContent, + nsIAtom* aTag, + int32_t aNameSpaceID, + PendingBinding* aPendingBinding, + already_AddRefed<nsStyleContext>& aStyleContext, + bool aSuppressWhiteSpaceOptimizations, + nsTArray<nsIAnonymousContentCreator::ContentInfo>* aAnonChildren) : + mFCData(aFCData), mContent(aContent), mTag(aTag), + mPendingBinding(aPendingBinding), mStyleContext(aStyleContext), + mNameSpaceID(aNameSpaceID), + mSuppressWhiteSpaceOptimizations(aSuppressWhiteSpaceOptimizations), + mIsText(false), mIsGeneratedContent(false), + mIsAnonymousContentCreatorContent(false), + mIsRootPopupgroup(false), mIsAllInline(false), mIsBlock(false), + mHasInlineEnds(false), mIsPopup(false), + mIsLineParticipant(false), mIsForSVGAElement(false) + { + if (aAnonChildren) { + NS_ASSERTION(!(mFCData->mBits & FCDATA_FUNC_IS_FULL_CTOR) || + mFCData->mFullConstructor == + &nsCSSFrameConstructor::ConstructInline, + "This is going to fail"); + NS_ASSERTION(!(mFCData->mBits & FCDATA_USE_CHILD_ITEMS), + "nsIAnonymousContentCreator::CreateAnonymousContent " + "implementations should not output a list where the " + "items have children in this case"); + mAnonChildren.SwapElements(*aAnonChildren); + } + } + ~FrameConstructionItem() { + if (mIsGeneratedContent) { + mContent->UnbindFromTree(); + NS_RELEASE(mContent); + } + } + + ParentType DesiredParentType() { + return FCDATA_DESIRED_PARENT_TYPE(mFCData->mBits); + } + + // Indicates whether (when in a flex or grid container) this item needs + // to be wrapped in an anonymous block. (Note that we implement + // -webkit-box/-webkit-inline-box using our standard flexbox frame class, + // but we use different rules for what gets wrapped. The aIsWebkitBox + // parameter here tells us whether to use those different rules.) + bool NeedsAnonFlexOrGridItem(const nsFrameConstructorState& aState, + bool aIsWebkitBox); + + // Don't call this unless the frametree really depends on the answer! + // Especially so for generated content, where we don't want to reframe + // things. + bool IsWhitespace(nsFrameConstructorState& aState) const; + + bool IsLineBoundary() const { + return mIsBlock || (mFCData->mBits & FCDATA_IS_LINE_BREAK); + } + + // Child frame construction items. + FrameConstructionItemList mChildItems; + + // ContentInfo list for children that have yet to have + // FrameConstructionItem objects created for them. This exists because + // AddFrameConstructionItemsInternal needs a valid frame, but in the case + // that nsIAnonymousContentCreator::CreateAnonymousContent returns items + // that have their own children (so we have a tree of ContentInfo objects + // rather than a flat list) we don't yet have a frame to provide to + // AddFrameConstructionItemsInternal in order to create the items for the + // grandchildren. That prevents FrameConstructionItems from being created + // for these grandchildren (and any descendants that they may have), + // otherwise they could have been added to the mChildItems member of their + // parent FrameConstructionItem. As it is, the grandchildren ContentInfo + // list has to be stored in this mAnonChildren member in order to delay + // construction of the FrameConstructionItems for the grandchildren until + // a frame has been created for their parent item. + nsTArray<nsIAnonymousContentCreator::ContentInfo> mAnonChildren; + + // The FrameConstructionData to use. + const FrameConstructionData* mFCData; + // The nsIContent node to use when initializing the new frame. + nsIContent* mContent; + // The XBL-resolved tag name to use for frame construction. + nsIAtom* mTag; + // The PendingBinding for this frame construction item, if any. May be + // null. We maintain a list of PendingBindings in the frame construction + // state in the order in which AddToAttachedQueue should be called on them: + // depth-first, post-order traversal order. Since we actually traverse the + // DOM in a mix of breadth-first and depth-first, it is the responsibility + // of whoever constructs FrameConstructionItem kids of a given + // FrameConstructionItem to push its mPendingBinding as the current + // insertion point before doing so and pop it afterward. + PendingBinding* mPendingBinding; + // The style context to use for creating the new frame. + RefPtr<nsStyleContext> mStyleContext; + // The XBL-resolved namespace to use for frame construction. + int32_t mNameSpaceID; + // Whether optimizations to skip constructing textframes around + // this content need to be suppressed. + bool mSuppressWhiteSpaceOptimizations:1; + // Whether this is a text content item. + bool mIsText:1; + // Whether this is a generated content container. + // If it is, mContent is a strong pointer. + bool mIsGeneratedContent:1; + // Whether this is an item for nsIAnonymousContentCreator content. + bool mIsAnonymousContentCreatorContent:1; + // Whether this is an item for the root popupgroup. + bool mIsRootPopupgroup:1; + // Whether construction from this item will create only frames that are + // IsInlineOutside() in the principal child list. This is not precise, but + // conservative: if true the frames will really be inline, whereas if false + // they might still all be inline. + bool mIsAllInline:1; + // Whether construction from this item will create only frames that are + // IsBlockOutside() in the principal child list. This is not precise, but + // conservative: if true the frames will really be blocks, whereas if false + // they might still be blocks (and in particular, out-of-flows that didn't + // find a containing block). + bool mIsBlock:1; + // Whether construction from this item will give leading and trailing + // inline frames. This is equal to mIsAllInline, except for inline frame + // items, where it's always true, whereas mIsAllInline might be false due + // to {ib} splits. + bool mHasInlineEnds:1; + // Whether construction from this item will create a popup that needs to + // go into the global popup items. + bool mIsPopup:1; + // Whether this item should be treated as a line participant + bool mIsLineParticipant:1; + // Whether this item is for an SVG <a> element + bool mIsForSVGAElement:1; + + private: + FrameConstructionItem(const FrameConstructionItem& aOther) = delete; /* not implemented */ + }; + + /** + * Function to create the anonymous flex or grid items that we need. + * If aParentFrame is not a nsFlexContainerFrame or nsGridContainerFrame then + * this method is a NOP. + * @param aItems the child frame construction items before pseudo creation + * @param aParentFrame the parent frame + */ + void CreateNeededAnonFlexOrGridItems(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsIFrame* aParentFrame); + + enum RubyWhitespaceType + { + eRubyNotWhitespace, + eRubyInterLevelWhitespace, + // Includes inter-base and inter-annotation whitespace + eRubyInterLeafWhitespace, + eRubyInterSegmentWhitespace + }; + + /** + * Function to compute the whitespace type according to the display + * values of the previous and the next elements. + */ + static inline RubyWhitespaceType ComputeRubyWhitespaceType( + mozilla::StyleDisplay aPrevDisplay, mozilla::StyleDisplay aNextDisplay); + + /** + * Function to interpret the type of whitespace between + * |aStartIter| and |aEndIter|. + */ + static inline RubyWhitespaceType InterpretRubyWhitespace( + nsFrameConstructorState& aState, + const FCItemIterator& aStartIter, const FCItemIterator& aEndIter); + + /** + * Function to wrap consecutive misparented inline content into + * a ruby base box or a ruby text box. + */ + void WrapItemsInPseudoRubyLeafBox(FCItemIterator& aIter, + nsStyleContext* aParentStyle, + nsIContent* aParentContent); + + /** + * Function to wrap consecutive misparented items + * into a ruby level container. + */ + inline void WrapItemsInPseudoRubyLevelContainer( + nsFrameConstructorState& aState, FCItemIterator& aIter, + nsStyleContext* aParentStyle, nsIContent* aParentContent); + + /** + * Function to trim leading and trailing whitespaces. + */ + inline void TrimLeadingAndTrailingWhitespaces( + nsFrameConstructorState& aState, FrameConstructionItemList& aItems); + + /** + * Function to create internal ruby boxes. + */ + inline void CreateNeededPseudoInternalRubyBoxes( + nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, nsIFrame* aParentFrame); + + /** + * Function to create the pseudo intermediate containers we need. + * @param aItems the child frame construction items before pseudo creation + * @param aParentFrame the parent frame we're creating pseudos for + */ + inline void CreateNeededPseudoContainers(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsIFrame* aParentFrame); + + /** + * Function to wrap consecutive items into a pseudo parent. + */ + inline void WrapItemsInPseudoParent(nsIContent* aParentContent, + nsStyleContext* aParentStyle, + ParentType aWrapperType, + FCItemIterator& aIter, + const FCItemIterator& aEndIter); + + /** + * Function to create the pseudo siblings we need. + */ + inline void CreateNeededPseudoSiblings(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsIFrame* aParentFrame); + + /** + * Function to adjust aParentFrame to deal with captions. + * @param aParentFrame the frame we think should be the parent. This will be + * adjusted to point to the right parent frame. + * @param aFCData the FrameConstructionData that would be used for frame + * construction. + * @param aStyleContext the style context for aChildContent + */ + // XXXbz this function should really go away once we rework pseudo-frame + // handling to be better. This should simply be part of the job of + // GetGeometricParent, and stuff like the frameitems and parent frame should + // be kept track of in the state... + void AdjustParentFrame(nsContainerFrame** aParentFrame, + const FrameConstructionData* aFCData, + nsStyleContext* aStyleContext); + + // END TABLE SECTION + +protected: + static nsIFrame* CreatePlaceholderFrameFor(nsIPresShell* aPresShell, + nsIContent* aContent, + nsIFrame* aFrame, + nsStyleContext* aParentStyle, + nsContainerFrame* aParentFrame, + nsIFrame* aPrevInFlow, + nsFrameState aTypeBit); + + static nsIFrame* CreateBackdropFrameFor(nsIPresShell* aPresShell, + nsIContent* aContent, + nsIFrame* aFrame, + nsContainerFrame* aParentFrame); + +private: + // ConstructSelectFrame puts the new frame in aFrameItems and + // handles the kids of the select. + nsIFrame* ConstructSelectFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + + // ConstructFieldSetFrame puts the new frame in aFrameItems and + // handles the kids of the fieldset + nsIFrame* ConstructFieldSetFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + + // ConstructDetailsFrame puts the new frame in aFrameItems and + // handles the kids of the details. + nsIFrame* ConstructDetailsFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameItems& aFrameItems); + + // aParentFrame might be null. If it is, that means it was an + // inline frame. + static const FrameConstructionData* FindTextData(nsIFrame* aParentFrame); + + void ConstructTextFrame(const FrameConstructionData* aData, + nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsStyleContext* aStyleContext, + nsFrameItems& aFrameItems); + + // If aPossibleTextContent is a text node and doesn't have a frame, append a + // frame construction item for it to aItems. + void AddTextItemIfNeeded(nsFrameConstructorState& aState, + const InsertionPoint& aInsertion, + nsIContent* aPossibleTextContent, + FrameConstructionItemList& aItems); + + // If aParentContent's child aContent is a text node and + // doesn't have a frame, try to create a frame for it. + void ReframeTextIfNeeded(nsIContent* aParentContent, + nsIContent* aContent); + + void AddPageBreakItem(nsIContent* aContent, + nsStyleContext* aMainStyleContext, + FrameConstructionItemList& aItems); + + // Function to find FrameConstructionData for aElement. Will return + // null if aElement is not HTML. + // aParentFrame might be null. If it is, that means it was an + // inline frame. + static const FrameConstructionData* FindHTMLData(Element* aContent, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsIFrame* aParentFrame, + nsStyleContext* aStyleContext); + // HTML data-finding helper functions + static const FrameConstructionData* + FindImgData(Element* aElement, nsStyleContext* aStyleContext); + static const FrameConstructionData* + FindImgControlData(Element* aElement, nsStyleContext* aStyleContext); + static const FrameConstructionData* + FindInputData(Element* aElement, nsStyleContext* aStyleContext); + static const FrameConstructionData* + FindObjectData(Element* aElement, nsStyleContext* aStyleContext); + static const FrameConstructionData* + FindCanvasData(Element* aElement, nsStyleContext* aStyleContext); + + /* Construct a frame from the given FrameConstructionItem. This function + will handle adding the frame to frame lists, processing children, setting + the frame as the primary frame for the item's content, and so forth. + + @param aItem the FrameConstructionItem to use. + @param aState the frame construction state to use. + @param aParentFrame the frame to set as the parent of the + newly-constructed frame. + @param aFrameItems the frame list to add the new frame (or its + placeholder) to. + */ + void ConstructFrameFromItemInternal(FrameConstructionItem& aItem, + nsFrameConstructorState& aState, + nsContainerFrame* aParentFrame, + nsFrameItems& aFrameItems); + + // possible flags for AddFrameConstructionItemInternal's aFlags argument + /* Allow xbl:base to affect the tag/namespace used. */ +#define ITEM_ALLOW_XBL_BASE 0x1 + /* Allow page-break before and after items to be created if the + style asks for them. */ +#define ITEM_ALLOW_PAGE_BREAK 0x2 + /* The item is a generated content item. */ +#define ITEM_IS_GENERATED_CONTENT 0x4 + /* The item is within an SVG text block frame. */ +#define ITEM_IS_WITHIN_SVG_TEXT 0x8 + /* The item allows items to be created for SVG <textPath> children. */ +#define ITEM_ALLOWS_TEXT_PATH_CHILD 0x10 + /* The item is content created by an nsIAnonymousContentCreator frame */ +#define ITEM_IS_ANONYMOUSCONTENTCREATOR_CONTENT 0x20 + // The guts of AddFrameConstructionItems + // aParentFrame might be null. If it is, that means it was an + // inline frame. + void AddFrameConstructionItemsInternal(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsIAtom* aTag, + int32_t aNameSpaceID, + bool aSuppressWhiteSpaceOptimizations, + nsStyleContext* aStyleContext, + uint32_t aFlags, + nsTArray<nsIAnonymousContentCreator::ContentInfo>* aAnonChildren, + FrameConstructionItemList& aItems); + + /** + * Construct frames for the given item list and parent frame, and put the + * resulting frames in aFrameItems. + */ + void ConstructFramesFromItemList(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsContainerFrame* aParentFrame, + nsFrameItems& aFrameItems); + void ConstructFramesFromItem(nsFrameConstructorState& aState, + FCItemIterator& aItem, + nsContainerFrame* aParentFrame, + nsFrameItems& aFrameItems); + static bool AtLineBoundary(FCItemIterator& aIter); + + nsresult CreateAnonymousFrames(nsFrameConstructorState& aState, + nsIContent* aParent, + nsContainerFrame* aParentFrame, + PendingBinding* aPendingBinding, + nsFrameItems& aChildItems); + + nsresult GetAnonymousContent(nsIContent* aParent, + nsIFrame* aParentFrame, + nsTArray<nsIAnonymousContentCreator::ContentInfo>& aAnonContent); + +//MathML Mod - RBS + /** + * Takes the frames in aBlockItems and wraps them in a new anonymous block + * frame whose content is aContent and whose parent will be aParentFrame. + * The anonymous block is added to aNewItems and aBlockItems is cleared. + */ + void FlushAccumulatedBlock(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsFrameItems& aBlockItems, + nsFrameItems& aNewItems); + + // Function to find FrameConstructionData for aContent. Will return + // null if aContent is not MathML. + static const FrameConstructionData* FindMathMLData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsStyleContext* aStyleContext); + + // Function to find FrameConstructionData for aContent. Will return + // null if aContent is not XUL. + static const FrameConstructionData* FindXULTagData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsStyleContext* aStyleContext); + // XUL data-finding helper functions and structures +#ifdef MOZ_XUL + static const FrameConstructionData* + FindPopupGroupData(Element* aElement, nsStyleContext* aStyleContext); + // sXULTextBoxData used for both labels and descriptions + static const FrameConstructionData sXULTextBoxData; + static const FrameConstructionData* + FindXULLabelData(Element* aElement, nsStyleContext* aStyleContext); + static const FrameConstructionData* + FindXULDescriptionData(Element* aElement, nsStyleContext* aStyleContext); +#ifdef XP_MACOSX + static const FrameConstructionData* + FindXULMenubarData(Element* aElement, nsStyleContext* aStyleContext); +#endif /* XP_MACOSX */ + static const FrameConstructionData* + FindXULListBoxBodyData(Element* aElement, nsStyleContext* aStyleContext); + static const FrameConstructionData* + FindXULListItemData(Element* aElement, nsStyleContext* aStyleContext); +#endif /* MOZ_XUL */ + + // Function to find FrameConstructionData for aContent using one of the XUL + // display types. Will return null if aDisplay doesn't have a XUL display + // type. This function performs no other checks, so should only be called if + // we know for sure that the content is not something that should get a frame + // constructed by tag. + static const FrameConstructionData* + FindXULDisplayData(const nsStyleDisplay* aDisplay, + Element* aElement, + nsStyleContext* aStyleContext); + + /** + * Constructs an outer frame, an anonymous child that wraps its real + * children, and its descendant frames. This is used by both ConstructOuterSVG + * and ConstructMarker, which both want an anonymous block child for their + * children to go in to. + */ + nsContainerFrame* ConstructFrameWithAnonymousChild( + nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + nsFrameItems& aFrameItems, + ContainerFrameCreationFunc aConstructor, + ContainerFrameCreationFunc aInnerConstructor, + nsICSSAnonBoxPseudo* aInnerPseudo, + bool aCandidateRootFrame); + + /** + * Construct an nsSVGOuterSVGFrame. + */ + nsIFrame* ConstructOuterSVG(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems); + + /** + * Construct an nsSVGMarkerFrame. + */ + nsIFrame* ConstructMarker(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems); + + static const FrameConstructionData* FindSVGData(Element* aElement, + nsIAtom* aTag, + int32_t aNameSpaceID, + nsIFrame* aParentFrame, + bool aIsWithinSVGText, + bool aAllowsTextPathChild, + nsStyleContext* aStyleContext); + + /* Not static because it does PropagateScrollToViewport. If this + changes, make this static */ + const FrameConstructionData* + FindDisplayData(const nsStyleDisplay* aDisplay, Element* aElement, + nsStyleContext* aStyleContext); + + /** + * Construct a scrollable block frame + */ + nsIFrame* ConstructScrollableBlock(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems); + + /** + * Construct a scrollable block frame using the given block frame creation + * function. + */ + nsIFrame* ConstructScrollableBlockWithConstructor( + nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems, + BlockFrameCreationFunc aConstructor); + + /** + * Construct a non-scrollable block frame + */ + nsIFrame* ConstructNonScrollableBlock(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems); + + /** + * Construct a non-scrollable block frame using the given block frame creation + * function. + */ + nsIFrame* ConstructNonScrollableBlockWithConstructor( + nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems, + BlockFrameCreationFunc aConstructor); + + /** + * This adds FrameConstructionItem objects to aItemsToConstruct for the + * anonymous content returned by an nsIAnonymousContentCreator:: + * CreateAnonymousContent implementation. + */ + void AddFCItemsForAnonymousContent( + nsFrameConstructorState& aState, + nsContainerFrame* aFrame, + nsTArray<nsIAnonymousContentCreator::ContentInfo>& aAnonymousItems, + FrameConstructionItemList& aItemsToConstruct, + uint32_t aExtraFlags = 0); + + /** + * Construct the frames for the children of aContent. "children" is defined + * as "whatever FlattenedChildIterator returns for aContent". This means we're + * basically operating on children in the "flattened tree" per sXBL/XBL2. + * This method will also handle constructing ::before, ::after, + * ::first-letter, and ::first-line frames, as needed and if allowed. + * + * If the parent is a float containing block, this method will handle pushing + * it as the float containing block in aState (so there's no need for callers + * to push it themselves). + * + * @param aState the frame construction state + * @param aContent the content node whose children need frames + * @param aStyleContext the style context for aContent + * @param aParentFrame the frame to use as the parent frame for the new in-flow + * kids. Note that this must be its own content insertion frame, but + * need not be be the primary frame for aContent. This frame will be + * pushed as the float containing block, as needed. aFrame is also + * used to find the parent style context for the kids' style contexts + * (not necessary aFrame's style context). + * @param aCanHaveGeneratedContent Whether to allow :before and + * :after styles on the parent. + * @param aFrameItems the list in which we should place the in-flow children + * @param aAllowBlockStyles Whether to allow first-letter and first-line + * styles on the parent. + * @param aPendingBinding Make sure to push this into aState before doing any + * child item construction. + * @param aPossiblyLeafFrame if non-null, this should be used for the isLeaf + * test and the anonymous content creation. If null, aFrame will be + * used. + */ + void ProcessChildren(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aStyleContext, + nsContainerFrame* aParentFrame, + const bool aCanHaveGeneratedContent, + nsFrameItems& aFrameItems, + const bool aAllowBlockStyles, + PendingBinding* aPendingBinding, + nsIFrame* aPossiblyLeafFrame = nullptr); + + /** + * These two functions are used when we start frame creation from a non-root + * element. They should recreate the same state that we would have + * arrived at if we had built frames from the root frame to aFrame. + * Therefore, any calls to PushFloatContainingBlock and + * PushAbsoluteContainingBlock during frame construction should get + * corresponding logic in these functions. + */ +public: + enum ContainingBlockType { + ABS_POS, + FIXED_POS + }; + nsContainerFrame* GetAbsoluteContainingBlock(nsIFrame* aFrame, + ContainingBlockType aType); + nsContainerFrame* GetFloatContainingBlock(nsIFrame* aFrame); + +private: + // Build a scroll frame: + // Calls BeginBuildingScrollFrame, InitAndRestoreFrame, and then FinishBuildingScrollFrame. + // @param aNewFrame the created scrollframe --- output only + // @param aParentFrame the geometric parent that the scrollframe will have. + void + BuildScrollFrame(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aContentStyle, + nsIFrame* aScrolledFrame, + nsContainerFrame* aParentFrame, + nsContainerFrame*& aNewFrame); + + // Builds the initial ScrollFrame + already_AddRefed<nsStyleContext> + BeginBuildingScrollFrame(nsFrameConstructorState& aState, + nsIContent* aContent, + nsStyleContext* aContentStyle, + nsContainerFrame* aParentFrame, + nsIAtom* aScrolledPseudo, + bool aIsRoot, + nsContainerFrame*& aNewFrame); + + // Completes the building of the scrollframe: + // Creates a view for the scrolledframe and makes it the child of the scrollframe. + void + FinishBuildingScrollFrame(nsContainerFrame* aScrollFrame, + nsIFrame* aScrolledFrame); + + // InitializeSelectFrame puts scrollFrame in aFrameItems if aBuildCombobox is false + // aBuildCombobox indicates if we are building a combobox that has a dropdown + // popup widget or not. + nsresult + InitializeSelectFrame(nsFrameConstructorState& aState, + nsContainerFrame* aScrollFrame, + nsContainerFrame* aScrolledFrame, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsStyleContext* aStyleContext, + bool aBuildCombobox, + PendingBinding* aPendingBinding, + nsFrameItems& aFrameItems); + + /** + * ReResolve style for aElement then recreate frames if required. + * Do nothing for other types of style changes, except for undisplayed nodes + * (display:none/contents) which will have their style context updated in the + * frame manager undisplayed maps. + * @return null if frames were recreated, the new style context otherwise + */ + nsStyleContext* MaybeRecreateFramesForElement(Element* aElement); + + /** + * Recreate frames for aContent. + * @param aContent the content to recreate frames for + * @param aAsyncInsert if true then a restyle event will be posted to handle + * the required ContentInserted call instead of doing it immediately. + * @param aFlags normally you want to pass REMOVE_FOR_RECONSTRUCTION here + * @param aDestroyedFramesFor if non-null, it will contain the content that + * was actually reframed - it may be different than aContent. + */ + nsresult + RecreateFramesForContent(nsIContent* aContent, + bool aAsyncInsert, + RemoveFlags aFlags, + nsIContent** aDestroyedFramesFor); + + // If removal of aFrame from the frame tree requires reconstruction of some + // containing block (either of aFrame or of its parent) due to {ib} splits or + // table pseudo-frames, recreate the relevant frame subtree. The return value + // indicates whether this happened. If this method returns true, *aResult is + // the return value of ReframeContainingBlock or RecreateFramesForContent. If + // this method returns false, the value of *aResult is not affected. aFrame + // and aResult must not be null. aFrame must be the result of a + // GetPrimaryFrame() call on a content node (which means its parent is also + // not null). If this method returns true, aDestroyedFramesFor contains the + // content that was reframed. + bool MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame, + RemoveFlags aFlags, + nsresult* aResult, + nsIContent** aDestroyedFramesFor); + + nsIFrame* CreateContinuingOuterTableFrame(nsIPresShell* aPresShell, + nsPresContext* aPresContext, + nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + nsIContent* aContent, + nsStyleContext* aStyleContext); + + nsIFrame* CreateContinuingTableFrame(nsIPresShell* aPresShell, + nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + nsIContent* aContent, + nsStyleContext* aStyleContext); + + //---------------------------------------- + + // Methods support creating block frames and their children + + already_AddRefed<nsStyleContext> + GetFirstLetterStyle(nsIContent* aContent, + nsStyleContext* aStyleContext); + + already_AddRefed<nsStyleContext> + GetFirstLineStyle(nsIContent* aContent, + nsStyleContext* aStyleContext); + + bool ShouldHaveFirstLetterStyle(nsIContent* aContent, + nsStyleContext* aStyleContext); + + // Check whether a given block has first-letter style. Make sure to + // only pass in blocks! And don't pass in null either. + bool HasFirstLetterStyle(nsIFrame* aBlockFrame); + + bool ShouldHaveFirstLineStyle(nsIContent* aContent, + nsStyleContext* aStyleContext); + + void ShouldHaveSpecialBlockStyle(nsIContent* aContent, + nsStyleContext* aStyleContext, + bool* aHaveFirstLetterStyle, + bool* aHaveFirstLineStyle); + + // |aContentParentFrame| should be null if it's really the same as + // |aParentFrame|. + // @param aFrameItems where we want to put the block in case it's in-flow. + // @param aNewFrame an in/out parameter. On input it is the block to be + // constructed. On output it is reset to the outermost + // frame constructed (e.g. if we need to wrap the block in an + // nsColumnSetFrame. + // @param aParentFrame is the desired parent for the (possibly wrapped) + // block + // @param aContentParent is the parent the block would have if it + // were in-flow + // @param aPositionedFrameForAbsPosContainer if non-null, then the new + // block should be an abs-pos container and aPositionedFrameForAbsPosContainer + // is the frame whose style is making this block an abs-pos container. + // @param aPendingBinding the pending binding from this block's frame + // construction item. + void ConstructBlock(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsContainerFrame* aContentParentFrame, + nsStyleContext* aStyleContext, + nsContainerFrame** aNewFrame, + nsFrameItems& aFrameItems, + nsIFrame* aPositionedFrameForAbsPosContainer, + PendingBinding* aPendingBinding); + + nsIFrame* ConstructInline(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameItems& aFrameItems); + + /** + * Create any additional {ib} siblings needed to contain aChildItems and put + * them in aSiblings. + * + * @param aState the frame constructor state + * @param aInitialInline is an already-existing inline frame that will be + * part of this {ib} split and come before everything + * in aSiblings. + * @param aIsPositioned true if aInitialInline is positioned. + * @param aChildItems is a child list starting with a block; this method + * assumes that the inline has already taken all the + * children it wants. When the method returns aChildItems + * will be empty. + * @param aSiblings the nsFrameItems to put the newly-created siblings into. + * + * This method is responsible for making any SetFrameIsIBSplit calls that are + * needed. + */ + void CreateIBSiblings(nsFrameConstructorState& aState, + nsContainerFrame* aInitialInline, + bool aIsPositioned, + nsFrameItems& aChildItems, + nsFrameItems& aSiblings); + + /** + * For an inline aParentItem, construct its list of child + * FrameConstructionItems and set its mIsAllInline flag appropriately. + */ + void BuildInlineChildItems(nsFrameConstructorState& aState, + FrameConstructionItem& aParentItem, + bool aItemIsWithinSVGText, + bool aItemAllowsTextPathChild); + + // Determine whether we need to wipe out what we just did and start over + // because we're doing something like adding block kids to an inline frame + // (and therefore need an {ib} split). aPrevSibling must be correct, even in + // aIsAppend cases. Passing aIsAppend false even when an append is happening + // is ok in terms of correctness, but can lead to unnecessary reframing. If + // aIsAppend is true, then the caller MUST call + // nsCSSFrameConstructor::AppendFramesToParent (as opposed to + // nsFrameManager::InsertFrames directly) to add the new frames. + // @return true if we reconstructed the containing block, false + // otherwise + bool WipeContainingBlock(nsFrameConstructorState& aState, + nsIFrame* aContainingBlock, + nsIFrame* aFrame, + FrameConstructionItemList& aItems, + bool aIsAppend, + nsIFrame* aPrevSibling); + + nsresult ReframeContainingBlock(nsIFrame* aFrame, + RemoveFlags aFlags, + nsIContent** aReframeContent); + + //---------------------------------------- + + // Methods support :first-letter style + + void CreateFloatingLetterFrame(nsFrameConstructorState& aState, + nsIContent* aTextContent, + nsIFrame* aTextFrame, + nsContainerFrame* aParentFrame, + nsStyleContext* aStyleContext, + nsFrameItems& aResult); + + void CreateLetterFrame(nsContainerFrame* aBlockFrame, + nsContainerFrame* aBlockContinuation, + nsIContent* aTextContent, + nsContainerFrame* aParentFrame, + nsFrameItems& aResult); + + void WrapFramesInFirstLetterFrame(nsContainerFrame* aBlockFrame, + nsFrameItems& aBlockFrames); + + /** + * Looks in the block aBlockFrame for a text frame that contains the + * first-letter of the block and creates the necessary first-letter frames + * and returns them in aLetterFrames. + * + * @param aBlockFrame the (first-continuation of) the block we are creating a + * first-letter frame for + * @param aBlockContinuation the current continuation of the block that we + * are looking in for a textframe with suitable + * contents for first-letter + * @param aParentFrame the current frame whose children we are looking at for + * a suitable first-letter textframe + * @param aParentFrameList the first child of aParentFrame + * @param aModifiedParent returns the parent of the textframe that contains + * the first-letter + * @param aTextFrame returns the textframe that had the first-letter + * @param aPrevFrame returns the previous sibling of aTextFrame + * @param aLetterFrames returns the frames that were created + */ + void WrapFramesInFirstLetterFrame(nsContainerFrame* aBlockFrame, + nsContainerFrame* aBlockContinuation, + nsContainerFrame* aParentFrame, + nsIFrame* aParentFrameList, + nsContainerFrame** aModifiedParent, + nsIFrame** aTextFrame, + nsIFrame** aPrevFrame, + nsFrameItems& aLetterFrames, + bool* aStopLooking); + + void RecoverLetterFrames(nsContainerFrame* aBlockFrame); + + // + nsresult RemoveLetterFrames(nsIPresShell* aPresShell, + nsContainerFrame* aBlockFrame); + + // Recursive helper for RemoveLetterFrames + nsresult RemoveFirstLetterFrames(nsIPresShell* aPresShell, + nsContainerFrame* aFrame, + nsContainerFrame* aBlockFrame, + bool* aStopLooking); + + // Special remove method for those pesky floating first-letter frames + nsresult RemoveFloatingFirstLetterFrames(nsIPresShell* aPresShell, + nsIFrame* aBlockFrame); + + // Capture state for the frame tree rooted at the frame associated with the + // content object, aContent + void CaptureStateForFramesOf(nsIContent* aContent, + nsILayoutHistoryState* aHistoryState); + + //---------------------------------------- + + // Methods support :first-line style + + // This method chops the initial inline-outside frames out of aFrameItems. + // If aLineFrame is non-null, it appends them to that frame. Otherwise, it + // creates a new line frame, sets the inline frames as its initial child + // list, and inserts that line frame at the front of what's left of + // aFrameItems. In both cases, the kids are reparented to the line frame. + // After this call, aFrameItems holds the frames that need to become kids of + // the block (possibly including line frames). + void WrapFramesInFirstLineFrame(nsFrameConstructorState& aState, + nsIContent* aBlockContent, + nsContainerFrame* aBlockFrame, + nsFirstLineFrame* aLineFrame, + nsFrameItems& aFrameItems); + + // Handle the case when a block with first-line style is appended to (by + // possibly calling WrapFramesInFirstLineFrame as needed). + void AppendFirstLineFrames(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aBlockFrame, + nsFrameItems& aFrameItems); + + nsresult InsertFirstLineFrames(nsFrameConstructorState& aState, + nsIContent* aContent, + nsIFrame* aBlockFrame, + nsContainerFrame** aParentFrame, + nsIFrame* aPrevSibling, + nsFrameItems& aFrameItems); + + /** + * Find the right frame to use for aContent when looking for sibling + * frames for aTargetContent. If aPrevSibling is true, this + * will look for last continuations, etc, as necessary. This calls + * IsValidSibling as needed; if that returns false it returns null. + * + * @param aContent the content to search for frames + * @param aTargetContent the content we're finding a sibling frame for + * @param aTargetContentDisplay the CSS display enum for aTargetContent if + * already known, UNSET_DISPLAY otherwise. It will be filled in + * if needed. + * @param aParentFrame the nearest ancestor frame, used internally for + * finding ::after / ::before frames + * @param aPrevSibling true if we're searching in reverse DOM order + */ + nsIFrame* FindFrameForContentSibling(nsIContent* aContent, + nsIContent* aTargetContent, + mozilla::StyleDisplay& aTargetContentDisplay, + nsContainerFrame* aParentFrame, + bool aPrevSibling); + + /** + * Find the frame for the content immediately preceding the one aIter + * points to, following continuations if necessary. aIter is passed by + * value on purpose, so as not to modify the caller's iterator. + * + * @param aIter should be positioned such that aIter.GetPreviousChild() + * is the first content to search for frames + * @param aTargetContent the content we're finding a sibling frame for + * @param aTargetContentDisplay the CSS display enum for aTargetContent if + * already known, UNSET_DISPLAY otherwise. It will be filled in + * if needed. + * @param aParentFrame the nearest ancestor frame, used inernally for + * finding ::after / ::before frames + */ + nsIFrame* FindPreviousSibling(mozilla::dom::FlattenedChildIterator aIter, + nsIContent* aTargetContent, + mozilla::StyleDisplay& aTargetContentDisplay, + nsContainerFrame* aParentFrame); + + /** + * Find the frame for the content node immediately following the one aIter + * points to, following continuations if necessary. aIter is passed by value + * on purpose, so as not to modify the caller's iterator. + * + * @param aIter should be positioned such that aIter.GetNextChild() + * is the first content to search for frames + * @param aTargetContent the content we're finding a sibling frame for + * @param aTargetContentDisplay the CSS display enum for aTargetContent if + * already known, UNSET_DISPLAY otherwise. It will be filled in + * if needed. + * @param aParentFrame the nearest ancestor frame, used inernally for + * finding ::after / ::before frames + */ + nsIFrame* FindNextSibling(mozilla::dom::FlattenedChildIterator aIter, + nsIContent* aTargetContent, + mozilla::StyleDisplay& aTargetContentDisplay, + nsContainerFrame* aParentFrame); + + // Find the right previous sibling for an insertion. This also updates the + // parent frame to point to the correct continuation of the parent frame to + // use, and returns whether this insertion is to be treated as an append. + // aChild is the child being inserted. + // aIsRangeInsertSafe returns whether it is safe to do a range insert with + // aChild being the first child in the range. It is the callers' + // responsibility to check whether a range insert is safe with regards to + // fieldsets. + // The skip parameters are used to ignore a range of children when looking + // for a sibling. All nodes starting from aStartSkipChild and up to but not + // including aEndSkipChild will be skipped over when looking for sibling + // frames. Skipping a range can deal with XBL but not when there are multiple + // insertion points. + nsIFrame* GetInsertionPrevSibling(InsertionPoint* aInsertion, // inout + nsIContent* aChild, + bool* aIsAppend, + bool* aIsRangeInsertSafe, + nsIContent* aStartSkipChild = nullptr, + nsIContent *aEndSkipChild = nullptr); + + /** + * Return the insertion frame of the primary frame of aContent, or its nearest + * ancestor that isn't display:contents. + */ + nsContainerFrame* GetContentInsertionFrameFor(nsIContent* aContent); + + // see if aContent and aSibling are legitimate siblings due to restrictions + // imposed by table columns + // XXXbz this code is generally wrong, since the frame for aContent + // may be constructed based on tag, not based on aDisplay! + bool IsValidSibling(nsIFrame* aSibling, + nsIContent* aContent, + mozilla::StyleDisplay& aDisplay); + + void QuotesDirty() { + NS_PRECONDITION(mUpdateCount != 0, "Instant quote updates are bad news"); + mQuotesDirty = true; + mDocument->SetNeedLayoutFlush(); + } + + void CountersDirty() { + NS_PRECONDITION(mUpdateCount != 0, "Instant counter updates are bad news"); + mCountersDirty = true; + mDocument->SetNeedLayoutFlush(); + } + + /** + * Add the pair (aContent, aStyleContext) to the undisplayed items + * in aList as needed. This method enforces the invariant that all + * style contexts in the undisplayed content map must be non-pseudo + * contexts and also handles unbinding undisplayed generated content + * as needed. + */ + void SetAsUndisplayedContent(nsFrameConstructorState& aState, + FrameConstructionItemList& aList, + nsIContent* aContent, + nsStyleContext* aStyleContext, + bool aIsGeneratedContent); + // Create touch caret frame. + void ConstructAnonymousContentForCanvas(nsFrameConstructorState& aState, + nsIFrame* aFrame, + nsIContent* aDocElement); + +public: + + friend class nsFrameConstructorState; + +private: + + nsIDocument* mDocument; // Weak ref + + // See the comment at the start of ConstructRootFrame for more details + // about the following frames. + + // This is just the outermost frame for the root element. + nsContainerFrame* mRootElementFrame; + // This is the frame for the root element that has no pseudo-element style. + nsIFrame* mRootElementStyleFrame; + // This is the containing block that contains the root element --- + // the real "initial containing block" according to CSS 2.1. + nsContainerFrame* mDocElementContainingBlock; + nsIFrame* mGfxScrollFrame; + nsIFrame* mPageSequenceFrame; + nsQuoteList mQuoteList; + nsCounterManager mCounterManager; + // Current ProcessChildren depth. + uint16_t mCurrentDepth; +#ifdef DEBUG + uint16_t mUpdateCount; +#endif + bool mQuotesDirty : 1; + bool mCountersDirty : 1; + bool mIsDestroyingFrameTree : 1; + // This is true if mDocElementContainingBlock supports absolute positioning + bool mHasRootAbsPosContainingBlock : 1; + bool mAlwaysCreateFramesForIgnorableWhitespace : 1; + + nsCOMPtr<nsILayoutHistoryState> mTempFrameTreeState; +}; + +#endif /* nsCSSFrameConstructor_h___ */ |