diff options
Diffstat (limited to 'layout/base/nsCSSFrameConstructor.h')
| -rw-r--r-- | layout/base/nsCSSFrameConstructor.h | 2159 |
1 files changed, 2159 insertions, 0 deletions
diff --git a/layout/base/nsCSSFrameConstructor.h b/layout/base/nsCSSFrameConstructor.h new file mode 100644 index 0000000000..1b48fd15dc --- /dev/null +++ b/layout/base/nsCSSFrameConstructor.h @@ -0,0 +1,2159 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/ArenaAllocator.h" +#include "mozilla/Attributes.h" +#include "mozilla/ContainStyleScopeManager.h" +#include "mozilla/FunctionRef.h" +#include "mozilla/LinkedList.h" +#include "mozilla/Maybe.h" +#include "mozilla/ScrollStyles.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/PresShell.h" + +#include "nsCOMPtr.h" +#include "nsILayoutHistoryState.h" +#include "nsIAnonymousContentCreator.h" +#include "nsFrameManager.h" +#include "nsIFrame.h" + +struct nsStyleDisplay; +struct nsGenConInitializer; + +class nsBlockFrame; +class nsContainerFrame; +class nsFirstLineFrame; +class nsFirstLetterFrame; +class nsCSSAnonBoxPseudoStaticAtom; +class nsPageSequenceFrame; + +class nsPageContentFrame; + +class nsFrameConstructorState; + +namespace mozilla { + +class ComputedStyle; +class PresShell; +class PrintedSheetFrame; +class RestyleManager; + +namespace dom { + +class CharacterData; +class Text; +class FlattenedChildIterator; + +} // namespace dom +} // namespace mozilla + +class nsCSSFrameConstructor final : public nsFrameManager { + public: + using ComputedStyle = mozilla::ComputedStyle; + using PseudoStyleType = mozilla::PseudoStyleType; + using PresShell = mozilla::PresShell; + using Element = mozilla::dom::Element; + using Text = mozilla::dom::Text; + + // FIXME(emilio): Is this really needed? + friend class mozilla::RestyleManager; + + nsCSSFrameConstructor(mozilla::dom::Document* aDocument, + PresShell* aPresShell); + ~nsCSSFrameConstructor() { MOZ_ASSERT(mFCItemsInUse == 0); } + + static void GetAlternateTextFor(const Element&, nsAString& aAltText); + + private: + nsCSSFrameConstructor(const nsCSSFrameConstructor& aCopy) = delete; + nsCSSFrameConstructor& operator=(const nsCSSFrameConstructor& aCopy) = delete; + + public: + /** + * Whether insertion should be done synchronously or asynchronously. + * + * Generally, insertion is synchronous if we're entering frame construction + * from restyle processing, and async if we're removing stuff, or need to + * reconstruct some ancestor. + * + * Note that constructing async from frame construction will post a restyle + * event, but won't need another whole refresh driver tick to go in. Instead + * change hint processing will keep going as long as there are changes in the + * queue. + */ + enum class InsertionKind { + Sync, + Async, + }; + + mozilla::RestyleManager* RestyleManager() const { + return mPresShell->GetPresContext()->RestyleManager(); + } + + nsIFrame* ConstructRootFrame(); + + private: + enum Operation { CONTENTAPPEND, CONTENTINSERT }; + + // aChild is the child being inserted for inserts, and the first + // child being appended for appends. + void ConstructLazily(Operation aOperation, nsIContent* aChild); + +#ifdef DEBUG + void CheckBitsForLazyFrameConstruction(nsIContent* aParent); +#else + void CheckBitsForLazyFrameConstruction(nsIContent*) {} +#endif + + // Issues a single ContentInserted for each child in the range + // [aStartChild, aEndChild). + void IssueSingleInsertNofications(nsIContent* aStartChild, + nsIContent* aEndChild, InsertionKind); + + /** + * Data that represents an insertion point for some child content. + */ + struct InsertionPoint { + InsertionPoint() : mParentFrame(nullptr), mContainer(nullptr) {} + + InsertionPoint(nsContainerFrame* aParentFrame, nsIContent* aContainer) + : mParentFrame(aParentFrame), mContainer(aContainer) {} + + /** + * 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; + + /** + * Whether it is required to insert children one-by-one instead of as a + * range. + */ + bool IsMultiple() const; + }; + + /** + * Checks if the children 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* aStartChild, + nsIContent* aEndChild, InsertionKind); + + // Returns true if parent was recreated due to frameset child, false + // otherwise. + bool MaybeRecreateForFrameset(nsIFrame* aParentFrame, nsIContent* aStartChild, + nsIContent* aEndChild); + + /** + * For each child in the aStartChild/aEndChild range, calls + * NoteDirtyDescendantsForServo on their flattened tree parents. This is + * used when content is inserted into the document and we decide that + * we can do lazy frame construction. It handles children being rebound to + * different insertion points by calling NoteDirtyDescendantsForServo on each + * child's flattened tree parent. Only used when we are styled by Servo. + */ + void LazilyStyleNewChildRange(nsIContent* aStartChild, nsIContent* aEndChild); + + /** + * For each child in the aStartChild/aEndChild range, calls StyleNewChildren + * on their flattened tree parents. This is used when content is inserted + * into the document and we decide that we cannot do lazy frame construction. + * It handles children being rebound to different insertion points by calling + * StyleNewChildren on each child's flattened tree parent. Only used when we + * are styled by Servo. + */ + void StyleNewChildRange(nsIContent* aStartChild, nsIContent* aEndChild); + + public: + /** + * Lazy frame construction is controlled by the InsertionKind 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. + * + * If we construct lazily, then we add 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 RestyleManager walks the dirty nodes during + * ProcessPostTraversal, and ends up calling Content{Appended,Inserted} with + * InsertionKind::Sync in ProcessRestyledFrames. + * + * 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 + * reconstruct frames. (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 the insertion kind is Async then frame construction of the new children + // can be done lazily. + void ContentAppended(nsIContent* aFirstNewContent, InsertionKind); + + // If the insertion kind is Async then frame construction of the new child + // can be done lazily. + void ContentInserted(nsIContent* aChild, InsertionKind); + + // Like ContentInserted but handles inserting the children in the range + // [aStartChild, aEndChild). aStartChild must be non-null. aEndChild may be + // null to indicate the range includes all kids after aStartChild. + // + // If aInsertionKind is Async then frame construction of the new children can + // be done lazily. It is only allowed to be Async when inserting a single + // node. + void ContentRangeInserted(nsIContent* aStartChild, nsIContent* aEndChild, + InsertionKind aInsertionKind); + + enum RemoveFlags { + REMOVE_CONTENT, + REMOVE_FOR_RECONSTRUCTION, + }; + + /** + * Recreate or destroy frames for aChild. + * + * 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 + * frames on some ancestor of aChild. This can happen regardless of the value + * of aFlags. + * + * The return value indicates whether this "reconstruct an ancestor" action + * took place. If true is returned, that means that the frame subtree rooted + * at some ancestor of aChild's frame was destroyed and will be reconstructed + * async. + */ + bool ContentRemoved(nsIContent* aChild, nsIContent* aOldNextSibling, + RemoveFlags aFlags); + + void CharacterDataChanged(nsIContent* aContent, + const 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), ensure that + // a frame for it is created the next time frames are flushed, if it can + // possibly have a frame at all. + // + // Returns whether there are chances for the frame to be unsuppressed. + bool EnsureFrameForTextNodeIsCreatedAfterFlush( + mozilla::dom::CharacterData* aContent); + + // Should be called when a frame is going to be destroyed and + // WillDestroyFrameTree hasn't been called yet. + void NotifyDestroyingFrame(nsIFrame* aFrame); + + 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. + * + * Returns whether a reconstruct was posted for any ancestor. + */ + bool DestroyFramesFor(nsIContent* aContent); + + // Request to create a continuing frame. This method never returns null. + nsIFrame* CreateContinuingFrame(nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + bool aIsFluid = true); + + void SetNextPageContentFramePageName(const nsAtom* aAtom) { + MOZ_ASSERT(!mNextPageContentFramePageName, + "PageContentFrame page name was already set"); + mNextPageContentFramePageName = aAtom; + } + + // Copy over fixed frames from aParentFrame's prev-in-flow + nsresult ReplicateFixedFrames(nsPageContentFrame* aParentFrame); + + /** + * Get the insertion point for aChild. + */ + InsertionPoint GetInsertionPoint(nsIContent* aChild); + + /** + * Return the insertion frame of the primary frame of aContent, or its nearest + * ancestor that isn't display:contents. + */ + nsContainerFrame* GetContentInsertionFrameFor(nsIContent* aContent); + + // 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; } + nsPageSequenceFrame* GetPageSequenceFrame() { return mPageSequenceFrame; } + // Returns the outermost canvas frame. There's usually one per document, but + // if but if we're in printing / paginated mode we might have multiple: one + // per page plus the background one. + nsCanvasFrame* GetCanvasFrame() { return mCanvasFrame; } + // Get the frame that is the parent of the root element's frame. + nsCanvasFrame* GetDocElementContainingBlock() { + return mDocElementContainingBlock; + } + + void AddSizeOfIncludingThis(nsWindowSizes& aSizes) const; + +#if defined(ACCESSIBILITY) || defined(MOZ_LAYOUT_DEBUGGER) + // Exposed only for nsLayoutUtils::GetMarkerSpokenText and + // nsLayoutDebuggingTools to use. + mozilla::ContainStyleScopeManager& GetContainStyleScopeManager() { + return mContainStyleScopeManager; + } +#endif + + private: + struct FrameConstructionItem; + class FrameConstructionItemList; + + mozilla::PrintedSheetFrame* ConstructPrintedSheetFrame( + PresShell* aPresShell, nsContainerFrame* aParentFrame, + nsIFrame* aPrevSheetFrame); + + nsContainerFrame* ConstructPageFrame(PresShell* aPresShell, + nsContainerFrame* aParentFrame, + nsIFrame* aPrevPageFrame, + nsCanvasFrame*& aCanvasFrame); + + void InitAndRestoreFrame(const nsFrameConstructorState& aState, + nsIContent* aContent, nsContainerFrame* aParentFrame, + nsIFrame* aNewFrame, bool aAllowCounters = true); + + already_AddRefed<ComputedStyle> ResolveComputedStyle(nsIContent* aContent); + + enum class ItemFlag : uint8_t { + // Allow page-break before and after items to be created if the + // style asks for them. + AllowPageBreak, + IsGeneratedContent, + IsWithinSVGText, + // The item allows items to be created for SVG <textPath> children. + AllowTextPathChild, + // The item is content created by an nsIAnonymousContentCreator frame. + IsAnonymousContentCreatorContent, + // The item will be the rendered legend of a <fieldset>. + IsForRenderedLegend, + // This will be an outside ::marker. + IsForOutsideMarker, + }; + + using ItemFlags = mozilla::EnumSet<ItemFlag>; + + // 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 ComputedStyle& aParentStyle, + const InsertionPoint& aInsertion, + FrameConstructionItemList& aItems, + ItemFlags = {}); + + // 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); + + // Construct the frames for the document element. This can return null if the + // document element is display:none, or if it's an SVG element that's not + // <svg>, etc. + nsIFrame* ConstructDocElementFrame(Element* aDocElement); + + // 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 (that + * is, the originating element). + * @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 aComputedStyle the style 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 + */ + void CreateAttributeContent(const Element& aParentContent, + nsIFrame* aParentFrame, int32_t aAttrNamespace, + nsAtom* aAttrName, ComputedStyle* aComputedStyle, + 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 nsAString& aString, + mozilla::UniquePtr<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 aOriginatingElement is the node that has the before/after style. + * @param aComputedStyle is the 'before' or 'after' pseudo-element style. + * @param aContentIndex is the index of the content item to create. + * @param aAddChild callback to be called for each generated content child. + */ + void CreateGeneratedContent( + nsFrameConstructorState& aState, Element& aOriginatingElement, + ComputedStyle& aPseudoStyle, uint32_t aContentIndex, + const mozilla::FunctionRef<void(nsIContent*)> aAddChild); + + /** + * Create child content nodes for a ::marker from its 'list-style-*' values. + */ + void CreateGeneratedContentFromListStyle( + nsFrameConstructorState& aState, Element& aOriginatingElement, + const ComputedStyle& aPseudoStyle, + const mozilla::FunctionRef<void(nsIContent*)> aAddChild); + /** + * Create child content nodes for a ::marker from its 'list-style-type'. + */ + void CreateGeneratedContentFromListStyleType( + nsFrameConstructorState& aState, Element& aOriginatingElement, + const ComputedStyle& aPseudoStyle, + const mozilla::FunctionRef<void(nsIContent*)> aAddChild); + + // aParentFrame may be null; this method doesn't use it directly in any case. + void CreateGeneratedContentItem(nsFrameConstructorState& aState, + nsContainerFrame* aParentFrame, + Element& aOriginatingElement, ComputedStyle&, + PseudoStyleType aPseudoElement, + FrameConstructionItemList& aItems, + ItemFlags aExtraFlags = {}); + + // This method is called by ContentAppended() and ContentRangeInserted() when + // appending flowed frames to a parent's principal child list. It handles the + // case where the parent is the trailing inline of an ib-split or is the last + // continuation of a ::-moz-column-content in an nsColumnSetFrame. + // + // This method can change aFrameList: it can chop off the beginning and put it + // in aParentFrame while either putting the remainder into an ib-split sibling + // of aParentFrame or creating aParentFrame's column-span siblings for the + // remainder. + // + // 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. + void AppendFramesToParent(nsFrameConstructorState& aState, + nsContainerFrame* aParentFrame, + nsFrameList& 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, + nsFrameList& aFrameList); + + /** + * FrameConstructionData callback for constructing table rows and row groups. + */ + nsIFrame* ConstructTableRowOrRowGroup(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + /** + * FrameConstructionData callback used for constructing table columns. + */ + nsIFrame* ConstructTableCol(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + /** + * FrameConstructionData callback used for constructing table cells. + */ + nsIFrame* ConstructTableCell(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + 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->Type()); + } + + /* Get the parent type for the given LayoutFrameType */ + static ParentType GetParentType(mozilla::LayoutFrameType 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 PresShell the presshell whose arena should be used to allocate + the frame. + @param ComputedStyle the style to use for the frame. */ + using FrameCreationFunc = nsIFrame* (*)(PresShell*, ComputedStyle*); + using ContainerFrameCreationFunc = nsContainerFrame* (*)(PresShell*, + ComputedStyle*); + using BlockFrameCreationFunc = nsBlockFrame* (*)(PresShell*, ComputedStyle*); + + /* 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 ComputedStyle the style to be used for the frame. + */ + struct FrameConstructionData; + using FrameConstructionDataGetter = + const FrameConstructionData* (*)(const Element&, ComputedStyle&); + + /* 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 aFrameList (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 aFrameList? 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 mComputedStyle + @param aFrameList 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. + */ + using FrameFullConstructor = + nsIFrame* (nsCSSFrameConstructor::*)(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + /* 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 + /* 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 + /* 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 IsLineParticipant() */ +#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 of a block (i.e. allow ::first-letter/line). + 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 + /** + * If FCDATA_ALLOW_GRID_FLEX_COLUMN is set, then we should create a + * grid/flex/column container instead of a block wrapper when the styles says + * so. This bit is meaningful only if FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS + * is also set. + */ +#define FCDATA_ALLOW_GRID_FLEX_COLUMN 0x200000 + /** + * Whether the kids of this FrameConstructionData should be flagged as having + * a wrapper anon box parent. This should only be set if + * FCDATA_USE_CHILD_ITEMS is set. + */ +#define FCDATA_IS_WRAPPER_ANON_BOX 0x400000 + + /* Structure representing information about how a frame should be + constructed. */ + struct FrameConstructionData { + // We have exactly one of three types of functions, so use a union for + // better cache locality. + union Func { + FrameCreationFunc mCreationFunc; + FrameConstructionDataGetter mDataGetter; + FrameFullConstructor mFullConstructor; + + explicit constexpr Func(FrameCreationFunc aFunc) : mCreationFunc(aFunc) {} + explicit constexpr Func(FrameConstructionDataGetter aDataGetter) + : mDataGetter(aDataGetter) {} + explicit constexpr Func(FrameFullConstructor aCtor) + : mFullConstructor(aCtor) {} + } mFunc; + // Flag bits that can modify the way the construction happens + const uint32_t mBits = 0; + // For cases when FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS is set, the + // anonymous box type to use for that wrapper. + PseudoStyleType const mAnonBoxPseudo = PseudoStyleType::NotPseudo; + + constexpr FrameConstructionData() : FrameConstructionData(nullptr) {} + + MOZ_IMPLICIT constexpr FrameConstructionData(std::nullptr_t, + uint32_t aBits = 0) + : mFunc(static_cast<FrameCreationFunc>(nullptr)), mBits(aBits) {} + + MOZ_IMPLICIT constexpr FrameConstructionData( + FrameCreationFunc aCreationFunc, uint32_t aBits = 0) + : mFunc(aCreationFunc), mBits(aBits) {} + constexpr FrameConstructionData(FrameCreationFunc aCreationFunc, + uint32_t aBits, + PseudoStyleType aAnonBoxPseudo) + : mFunc(aCreationFunc), + mBits(aBits | FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS), + mAnonBoxPseudo(aAnonBoxPseudo) {} + MOZ_IMPLICIT constexpr FrameConstructionData( + FrameConstructionDataGetter aDataGetter, uint32_t aBits = 0) + : mFunc(aDataGetter), + mBits(aBits | FCDATA_FUNC_IS_DATA_GETTER), + mAnonBoxPseudo(PseudoStyleType::NotPseudo) {} + MOZ_IMPLICIT constexpr FrameConstructionData(FrameFullConstructor aCtor, + uint32_t aBits = 0) + : mFunc(aCtor), + mBits(aBits | FCDATA_FUNC_IS_FULL_CTOR), + mAnonBoxPseudo(PseudoStyleType::NotPseudo) {} + }; + + /* Structure representing a mapping of an atom to a FrameConstructionData. + This can be used with non-static atoms, assuming that the nsAtom* is + stored somewhere that this struct can point to (that is, a static + nsAtom*) and that it's allocated before the struct is ever used. */ + struct FrameConstructionDataByTag { + const nsStaticAtom* 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; + }; + + /* Structure that has a FrameConstructionData and style pseudo-type + for a table pseudo-frame */ + struct PseudoParentData { + const FrameConstructionData mFCData; + mozilla::PseudoStyleType const mPseudoType; + }; + /* Array of such structures that we use to properly construct table + pseudo-frames as needed */ + static const PseudoParentData sPseudoParentData[eParentTypeCount]; + + const FrameConstructionData* FindDataForContent(nsIContent&, ComputedStyle&, + nsIFrame* aParentFrame, + ItemFlags aFlags); + + // aParentFrame might be null. If it is, that means it was an inline frame. + static const FrameConstructionData* FindTextData(const Text&, + nsIFrame* aParentFrame); + const FrameConstructionData* FindElementData(const Element&, ComputedStyle&, + nsIFrame* aParentFrame, + ItemFlags aFlags); + const FrameConstructionData* FindElementTagData(const Element&, + ComputedStyle&, + nsIFrame* aParentFrame, + ItemFlags aFlags); + + /* A function that takes an integer, content, style, 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, const Element&, ComputedStyle&, + const FrameConstructionDataByInt* aDataPtr, uint32_t aDataLength); + + /** + * A function that takes a tag, content, style, 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. In the case that the tags + * actually match, aTagFound will be true, even if the return value is null. + */ + static const FrameConstructionData* FindDataByTag( + const Element& aElement, ComputedStyle& aComputedStyle, + const FrameConstructionDataByTag* aDataPtr, uint32_t aDataLength); + + /* A class representing a list of FrameConstructionItems. Instances of this + class are only created as AutoFrameConstructionItemList, or as a member + of FrameConstructionItem. */ + class FrameConstructionItemList { + public: + void Reset(nsCSSFrameConstructor* aFCtor) { + Destroy(aFCtor); + this->~FrameConstructionItemList(); + new (this) FrameConstructionItemList(); + } + + void SetLineBoundaryAtStart(bool aBoundary) { + mLineBoundaryAtStart = aBoundary; + } + void SetLineBoundaryAtEnd(bool aBoundary) { + mLineBoundaryAtEnd = aBoundary; + } + void SetParentHasNoShadowDOM(bool aValue) { + mParentHasNoShadowDOM = aValue; + } + bool HasLineBoundaryAtStart() { return mLineBoundaryAtStart; } + bool HasLineBoundaryAtEnd() { return mLineBoundaryAtEnd; } + bool ParentHasNoShadowDOM() { return mParentHasNoShadowDOM; } + bool IsEmpty() const { return mItems.isEmpty(); } + 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( + nsCSSFrameConstructor* aFCtor, const FrameConstructionData* aFCData, + nsIContent* aContent, already_AddRefed<ComputedStyle>&& aComputedStyle, + bool aSuppressWhiteSpaceOptimizations) { + FrameConstructionItem* item = new (aFCtor) + FrameConstructionItem(aFCData, aContent, std::move(aComputedStyle), + aSuppressWhiteSpaceOptimizations); + mItems.insertBack(item); + ++mItemCount; + ++mDesiredParentCounts[item->DesiredParentType()]; + return item; + } + + // Arguments are the same as AppendItem(). + FrameConstructionItem* PrependItem( + nsCSSFrameConstructor* aFCtor, const FrameConstructionData* aFCData, + nsIContent* aContent, already_AddRefed<ComputedStyle>&& aComputedStyle, + bool aSuppressWhiteSpaceOptimizations) { + FrameConstructionItem* item = new (aFCtor) + FrameConstructionItem(aFCData, aContent, std::move(aComputedStyle), + aSuppressWhiteSpaceOptimizations); + mItems.insertFront(item); + ++mItemCount; + ++mDesiredParentCounts[item->DesiredParentType()]; + return item; + } + + void InlineItemAdded() { ++mInlineCount; } + void BlockItemAdded() { ++mBlockCount; } + + class Iterator { + public: + explicit Iterator(FrameConstructionItemList& aList) + : mCurrent(aList.mItems.getFirst()), mList(aList) {} + Iterator(const Iterator& aOther) = default; + + 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(nsCSSFrameConstructor* aFCtor, + 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(nsCSSFrameConstructor* aFCtor, const Iterator& aEnd); + + private: + FrameConstructionItem* mCurrent; + FrameConstructionItemList& mList; + }; + + protected: + FrameConstructionItemList() + : mInlineCount(0), + mBlockCount(0), + mItemCount(0), + mLineBoundaryAtStart(false), + mLineBoundaryAtEnd(false), + mParentHasNoShadowDOM(false) { + MOZ_COUNT_CTOR(FrameConstructionItemList); + memset(mDesiredParentCounts, 0, sizeof(mDesiredParentCounts)); + } + + void Destroy(nsCSSFrameConstructor* aFCtor) { + while (FrameConstructionItem* item = mItems.popFirst()) { + item->Delete(aFCtor); + } + } + + // Prevent stack instances (except as AutoFrameConstructionItemList). + friend struct FrameConstructionItem; + ~FrameConstructionItemList() { + MOZ_COUNT_DTOR(FrameConstructionItemList); + MOZ_ASSERT(mItems.isEmpty(), "leaking"); + } + + private: + // Not allocated from the heap! + void* operator new(size_t) = delete; + void* operator new[](size_t) = delete; +#ifdef _MSC_VER /* Visual Studio */ + void operator delete(void*) { MOZ_CRASH("FrameConstructionItemList::del"); } +#else + void operator delete(void*) = delete; +#endif + void operator delete[](void*) = delete; + // Placement new is used by Reset(). + void* operator new(size_t, void* aPtr) { return aPtr; } + + struct UndisplayedItem { + UndisplayedItem(nsIContent* aContent, ComputedStyle* aComputedStyle) + : mContent(aContent), mComputedStyle(aComputedStyle) {} + + nsIContent* const mContent; + RefPtr<ComputedStyle> mComputedStyle; + }; + + // 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 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 shadow tree. + bool mParentHasNoShadowDOM; + }; + + /* A struct representing a list of FrameConstructionItems on the stack. */ + struct MOZ_RAII AutoFrameConstructionItemList final + : public FrameConstructionItemList { + template <typename... Args> + explicit AutoFrameConstructionItemList(nsCSSFrameConstructor* aFCtor, + Args&&... args) + : FrameConstructionItemList(std::forward<Args>(args)...), + mFCtor(aFCtor) { + MOZ_ASSERT(mFCtor); + } + ~AutoFrameConstructionItemList() { Destroy(mFCtor); } + + private: + nsCSSFrameConstructor* const mFCtor; + }; + + 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. You probably want to use + * AutoFrameConstructionItem instead of this struct. */ + struct FrameConstructionItem final + : public mozilla::LinkedListElement<FrameConstructionItem> { + FrameConstructionItem(const FrameConstructionData* aFCData, + nsIContent* aContent, + already_AddRefed<ComputedStyle>&& aComputedStyle, + bool aSuppressWhiteSpaceOptimizations) + : mFCData(aFCData), + mContent(aContent), + mComputedStyle(std::move(aComputedStyle)), + mSuppressWhiteSpaceOptimizations(aSuppressWhiteSpaceOptimizations), + mIsText(false), + mIsGeneratedContent(false), + mIsAllInline(false), + mIsBlock(false), + mIsPopup(false), + mIsLineParticipant(false), + mIsRenderedLegend(false) { + MOZ_COUNT_CTOR(FrameConstructionItem); + } + + void* operator new(size_t, nsCSSFrameConstructor* aFCtor) { + return aFCtor->AllocateFCItem(); + } + + void Delete(nsCSSFrameConstructor* aFCtor) { + mChildItems.Destroy(aFCtor); + if (mIsGeneratedContent) { + mContent->UnbindFromTree(); + NS_RELEASE(mContent); + } + this->~FrameConstructionItem(); + aFCtor->FreeFCItem(this); + } + + 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; + + // The FrameConstructionData to use. + const FrameConstructionData* mFCData; + // The nsIContent node to use when initializing the new frame. + nsIContent* mContent; + // The style to use for creating the new frame. + RefPtr<ComputedStyle> mComputedStyle; + // 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 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 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 the rendered legend of a <fieldset> + bool mIsRenderedLegend : 1; + + private: + // Not allocated from the general heap - instead, use the new/Delete APIs + // that take a nsCSSFrameConstructor* (which manages our arena allocation). + void* operator new(size_t) = delete; + void* operator new[](size_t) = delete; +#ifdef _MSC_VER /* Visual Studio */ + void operator delete(void*) { MOZ_CRASH("FrameConstructionItem::delete"); } +#else + void operator delete(void*) = delete; +#endif + void operator delete[](void*) = delete; + FrameConstructionItem(const FrameConstructionItem& aOther) = delete; + // Not allocated from the stack! + ~FrameConstructionItem() { + MOZ_COUNT_DTOR(FrameConstructionItem); + MOZ_ASSERT(mChildItems.IsEmpty(), "leaking"); + } + }; + + /** + * Convenience struct to assist in managing a temporary FrameConstructionItem + * using a local variable. Castable to FrameConstructionItem so that it can + * be passed transparently to functions that expect that type. + * (This struct exists because FrameConstructionItem is arena-allocated, and + * it's nice to abstract away its allocation/deallocation.) + */ + struct MOZ_RAII AutoFrameConstructionItem final { + template <typename... Args> + explicit AutoFrameConstructionItem(nsCSSFrameConstructor* aFCtor, + Args&&... args) + : mFCtor(aFCtor), + mItem(new(aFCtor) + FrameConstructionItem(std::forward<Args>(args)...)) { + MOZ_ASSERT(mFCtor); + } + ~AutoFrameConstructionItem() { mItem->Delete(mFCtor); } + operator FrameConstructionItem&() { return *mItem; } + + private: + nsCSSFrameConstructor* const mFCtor; + FrameConstructionItem* const mItem; + }; + + /** + * Updates the nsFrameConstructorState auto page-name value, and restores the + * previous value on destruction. + * See https://drafts.csswg.org/css-page-3/#using-named-pages + * + * To track this, this will automatically add PageValuesProperty to + * the frame. + * + * Note that this does not add PageValuesProperty to the frame when not in a + * paginated context. + */ + class MOZ_RAII AutoFrameConstructionPageName final { + nsFrameConstructorState& mState; + const nsAtom* mNameToRestore; + + public: + AutoFrameConstructionPageName(const AutoFrameConstructionPageName&) = + delete; + AutoFrameConstructionPageName(AutoFrameConstructionPageName&&) = delete; + AutoFrameConstructionPageName(nsFrameConstructorState& aState, + nsIFrame* const aFrame); + ~AutoFrameConstructionPageName(); + }; + + /** + * 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, + ComputedStyle* aParentStyle, + nsIContent* aParentContent); + + /** + * Function to wrap consecutive misparented items + * into a ruby level container. + */ + inline void WrapItemsInPseudoRubyLevelContainer( + nsFrameConstructorState& aState, FCItemIterator& aIter, + ComputedStyle* 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, + ComputedStyle* 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); + + // END TABLE SECTION + + protected: + static nsIFrame* CreatePlaceholderFrameFor(PresShell* aPresShell, + nsIContent* aContent, + nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + nsIFrame* aPrevInFlow, + nsFrameState aTypeBit); + + private: + // ConstructSelectFrame puts the new frame in aFrameList and + // handles the kids of the select. + nsIFrame* ConstructSelectFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + // ConstructFieldSetFrame puts the new frame in aFrameList and + // handles the kids of the fieldset + nsIFrame* ConstructFieldSetFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + // Creates a block frame wrapping an anonymous ruby frame. + nsIFrame* ConstructBlockRubyFrame(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aStyleDisplay, + nsFrameList& aFrameList); + + void ConstructTextFrame(const FrameConstructionData* aData, + nsFrameConstructorState& aState, nsIContent* aContent, + nsContainerFrame* aParentFrame, + ComputedStyle* aComputedStyle, + nsFrameList& aFrameList); + + // 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 ComputedStyle& aParentStyle, + const InsertionPoint& aInsertion, + nsIContent* aPossibleTextContent, + FrameConstructionItemList& aItems); + + // If aContent is a text node and doesn't have a frame, try to create a frame + // for it. + void ReframeTextIfNeeded(nsIContent* aContent); + + enum InsertPageBreakLocation { eBefore, eAfter }; + inline void AppendPageBreakItem(nsIContent* aContent, + FrameConstructionItemList& aItems) { + InsertPageBreakItem(aContent, aItems, InsertPageBreakLocation::eAfter); + } + inline void PrependPageBreakItem(nsIContent* aContent, + FrameConstructionItemList& aItems) { + InsertPageBreakItem(aContent, aItems, InsertPageBreakLocation::eBefore); + } + void InsertPageBreakItem(nsIContent* aContent, + FrameConstructionItemList& aItems, + InsertPageBreakLocation location); + + // 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(const Element&, + nsIFrame* aParentFrame, + ComputedStyle&); + // HTML data-finding helper functions + static const FrameConstructionData* FindImgData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindGeneratedImageData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindImgControlData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindSearchControlData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindInputData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindObjectData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindCanvasData(const Element&, + ComputedStyle&); + // <details> always creates a block per spec. + static const FrameConstructionData* FindDetailsData(const Element&, + ComputedStyle&); + + /* 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 aFrameList the frame list to add the new frame (or its + placeholder) to. + */ + void ConstructFrameFromItemInternal(FrameConstructionItem& aItem, + nsFrameConstructorState& aState, + nsContainerFrame* aParentFrame, + nsFrameList& aFrameList); + + // 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, + bool aSuppressWhiteSpaceOptimizations, + ComputedStyle*, ItemFlags, + FrameConstructionItemList& aItems); + + /** + * Construct frames for the given item list and parent frame, and put the + * resulting frames in aFrameList. + */ + void ConstructFramesFromItemList(nsFrameConstructorState& aState, + FrameConstructionItemList& aItems, + nsContainerFrame* aParentFrame, + bool aParentIsWrapperAnonBox, + nsFrameList& aFrameList); + void ConstructFramesFromItem(nsFrameConstructorState& aState, + FCItemIterator& aItem, + nsContainerFrame* aParentFrame, + nsFrameList& aFrameList); + static bool AtLineBoundary(FCItemIterator& aIter); + + nsresult GetAnonymousContent( + nsIContent* aParent, nsIFrame* aParentFrame, + nsTArray<nsIAnonymousContentCreator::ContentInfo>& aAnonContent); + + // MathML Mod - RBS + /** + * Takes the frames in aBlockList 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 aNewList and aBlockList is cleared. + */ + void FlushAccumulatedBlock(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsFrameList& aBlockList, nsFrameList& aNewList); + + // Function to find FrameConstructionData for an element. Will return + // null if the element is not MathML. + static const FrameConstructionData* FindMathMLData(const Element&, + ComputedStyle&); + + // Function to find FrameConstructionData for an element. Will return + // null if the element is not XUL. + static const FrameConstructionData* FindXULTagData(const Element&, + ComputedStyle&); + // XUL data-finding helper functions and structures + static const FrameConstructionData* FindPopupGroupData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindXULButtonData(const Element&, + ComputedStyle&); + static const FrameConstructionData* FindXULLabelOrDescriptionData( + const Element&, ComputedStyle&); +#ifdef XP_MACOSX + static const FrameConstructionData* FindXULMenubarData(const Element&, + ComputedStyle&); +#endif /* XP_MACOSX */ + + /** + * 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, nsFrameList& aFrameList, + ContainerFrameCreationFunc aConstructor, + ContainerFrameCreationFunc aInnerConstructor, + mozilla::PseudoStyleType aInnerPseudo, bool aCandidateRootFrame); + + /** + * Construct an SVGOuterSVGFrame. + */ + nsIFrame* ConstructOuterSVG(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameList& aFrameList); + + /** + * Construct an SVGMarkerFrame. + */ + nsIFrame* ConstructMarker(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameList& aFrameList); + + static const FrameConstructionData* FindSVGData(const Element&, + nsIFrame* aParentFrame, + bool aIsWithinSVGText, + bool aAllowsTextPathChild, + ComputedStyle&); + + // Not static because it does PropagateScrollToViewport. If this + // changes, make this static. + const FrameConstructionData* FindDisplayData(const nsStyleDisplay&, + const Element&); + + /** + * Construct a scrollable block frame + */ + nsIFrame* ConstructScrollableBlock(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameList& aFrameList); + + /** + * Construct a non-scrollable block frame + */ + nsIFrame* ConstructNonScrollableBlock(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameList& aFrameList); + + /** + * This adds FrameConstructionItem objects to aItemsToConstruct for the + * anonymous content returned by an nsIAnonymousContentCreator:: + * CreateAnonymousContent implementation. + * This includes an AutoFrameConstructionPageName argument as it is always + * the caller's responsibility to handle page-name tracking before calling + * this function. + */ + void AddFCItemsForAnonymousContent( + nsFrameConstructorState& aState, nsContainerFrame* aFrame, + const nsTArray<nsIAnonymousContentCreator::ContentInfo>& aAnonymousItems, + FrameConstructionItemList& aItemsToConstruct, + const AutoFrameConstructionPageName& aUnusedPageNameTracker); + + /** + * 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": + * + * https://drafts.csswg.org/css-scoping/#flat-tree + * + * 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 aComputedStyle the style 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 for the kids' style + * (not necessary aFrame's style). + * @param aCanHaveGeneratedContent Whether to allow :before and + * :after styles on the parent. + * @param aFrameList 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 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, + ComputedStyle* aComputedStyle, + nsContainerFrame* aParentFrame, + const bool aCanHaveGeneratedContent, + nsFrameList& aFrameList, const bool aAllowBlockStyles, + 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, + ComputedStyle* aContentStyle, nsIFrame* aScrolledFrame, + nsContainerFrame* aParentFrame, + nsContainerFrame*& aNewFrame); + + // Builds the initial ScrollFrame + already_AddRefed<ComputedStyle> BeginBuildingScrollFrame( + nsFrameConstructorState& aState, nsIContent* aContent, + ComputedStyle* aContentStyle, nsContainerFrame* aParentFrame, + mozilla::PseudoStyleType 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); + + void InitializeListboxSelect(nsFrameConstructorState& aState, + nsContainerFrame* aScrollFrame, + nsContainerFrame* aScrolledFrame, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + ComputedStyle* aComputedStyle, + nsFrameList& aFrameList); + + /** + * Recreate frames for aContent. + * @param aContent the content to recreate frames for + * @param aFlags normally you want to pass REMOVE_FOR_RECONSTRUCTION here + */ + void RecreateFramesForContent(nsIContent* aContent, + InsertionKind aInsertionKind); + + /** + * Handles change of rowspan and colspan attributes on table cells. + */ + void UpdateTableCellSpans(nsIContent* aContent); + + // 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. aFrame must be the result of a + // GetPrimaryFrame() call on a content node (which means its parent is also + // not null). + bool MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame); + + nsIFrame* CreateContinuingOuterTableFrame(nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + nsIContent* aContent, + ComputedStyle* aComputedStyle); + + nsIFrame* CreateContinuingTableFrame(nsIFrame* aFrame, + nsContainerFrame* aParentFrame, + nsIContent* aContent, + ComputedStyle* aComputedStyle); + + //---------------------------------------- + + // Methods support creating block frames and their children + + already_AddRefed<ComputedStyle> GetFirstLetterStyle( + nsIContent* aContent, ComputedStyle* aComputedStyle); + + already_AddRefed<ComputedStyle> GetFirstLineStyle( + nsIContent* aContent, ComputedStyle* aComputedStyle); + + bool ShouldHaveFirstLetterStyle(nsIContent* aContent, + ComputedStyle* aComputedStyle); + + // 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, + ComputedStyle* aComputedStyle); + + void ShouldHaveSpecialBlockStyle(nsIContent* aContent, + ComputedStyle* aComputedStyle, + bool* aHaveFirstLetterStyle, + bool* aHaveFirstLineStyle); + + // |aContentParentFrame| should be null if it's really the same as + // |aParentFrame|. + // @param aFrameList 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. + void ConstructBlock(nsFrameConstructorState& aState, nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsContainerFrame* aContentParentFrame, + ComputedStyle* aComputedStyle, + nsContainerFrame** aNewFrame, nsFrameList& aFrameList, + nsIFrame* aPositionedFrameForAbsPosContainer); + + // Build the initial column hierarchy around aColumnContent. This function + // should be called before constructing aColumnContent's children. + // + // Before calling FinishBuildingColumns(), we need to create column-span + // siblings for aColumnContent's children. Caller can use helpers + // MayNeedToCreateColumnSpanSiblings() and CreateColumnSpanSiblings() to + // check whether column-span siblings might need to be created and to do + // the actual work of creating them if they're needed. + // + // @param aColumnContent the block that we're wrapping in a ColumnSet. On + // entry to this function it has aComputedStyle as its style. After + // this function returns, aColumnContent has a ::-moz-column-content + // anonymous box style. + // @param aParentFrame the parent frame we want to use for the + // ColumnSetWrapperFrame (which would have been the parent of + // aColumnContent if we were not creating a column hierarchy). + // @param aContent is the content of the aColumnContent. + // @return the outermost ColumnSetWrapperFrame. + nsBlockFrame* BeginBuildingColumns(nsFrameConstructorState& aState, + nsIContent* aContent, + nsContainerFrame* aParentFrame, + nsContainerFrame* aColumnContent, + ComputedStyle* aComputedStyle); + + // Complete building the column hierarchy by first wrapping each + // non-column-span child in aChildList in a ColumnSetFrame (skipping + // column-span children), and reparenting them to have aColumnSetWrapper + // as their parent. + // + // @param aColumnSetWrapper is the frame returned by + // BeginBuildingColumns(), and is the grandparent of aColumnContent. + // @param aColumnContent is the block frame passed into + // BeginBuildingColumns() + // @param aColumnContentSiblings contains the aColumnContent's siblings, which + // are the column spanners and aColumnContent's continuations returned + // by CreateColumnSpanSiblings(). It'll become empty after this call. + void FinishBuildingColumns(nsFrameConstructorState& aState, + nsContainerFrame* aColumnSetWrapper, + nsContainerFrame* aColumnContent, + nsFrameList& aColumnContentSiblings); + + // Return whether aBlockFrame's children in aChildList, which might + // contain column-span, may need to be wrapped in + // ::moz-column-span-wrapper and promoted as aBlockFrame's siblings. + // + // @param aBlockFrame is the parent of the frames in aChildList. + // + // Note: This a check without actually looking into each frame in the + // child list, so it may return false positive. + bool MayNeedToCreateColumnSpanSiblings(nsContainerFrame* aBlockFrame, + const nsFrameList& aChildList); + + // Wrap consecutive runs of column-span kids and runs of non-column-span + // kids in blocks for aInitialBlock's children. + // + // @param aInitialBlock is the parent of those frames in aChildList. + // @param aChildList must begin with a column-span kid. It becomes empty + // after this call. + // @param aPositionedFrame if non-null, it's the frame whose style is making + // aInitialBlock an abs-pos container. + // + // Return those wrapping blocks in nsFrameList. + nsFrameList CreateColumnSpanSiblings(nsFrameConstructorState& aState, + nsContainerFrame* aInitialBlock, + nsFrameList& aChildList, + nsIFrame* aPositionedFrame); + + // Reconstruct the multi-column containing block of aParentFrame when we want + // to insert aFrameList into aParentFrame immediately after aPrevSibling but + // cannot fix the frame tree because aFrameList contains some column-spans. + // + // Note: This method is intended to be called as a helper in ContentAppended() + // and ContentRangeInserted(). It assumes aState was set up locally and wasn't + // used to construct any ancestors of aParentFrame in aFrameList. + // + // @param aParentFrame the to-be parent frame for aFrameList. + // @param aFrameList the frames to be inserted. It will be cleared if we need + // reconstruction. + // @param aPrevSibling the position where the frames in aFrameList are going + // to be inserted. Nullptr means aFrameList is being inserted at + // the beginning. + // @return true if the multi-column containing block of aParentFrame is + // reconstructed; false otherwise. + bool MaybeRecreateForColumnSpan(nsFrameConstructorState& aState, + nsContainerFrame* aParentFrame, + nsFrameList& aFrameList, + nsIFrame* aPrevSibling); + + nsIFrame* ConstructInline(nsFrameConstructorState& aState, + FrameConstructionItem& aItem, + nsContainerFrame* aParentFrame, + const nsStyleDisplay* aDisplay, + nsFrameList& aFrameList); + + /** + * Create any additional {ib} siblings needed to contain aChildList 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 aChildList 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 aChildList + * will be empty. + * @param aSiblings the nsFrameList 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, + nsFrameList& aChildList, nsFrameList& 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 aFrame (the insertion parent) and + // rebuild the entire subtree when we insert or append new content under + // aFrame. + // + // This is similar to WipeContainingBlock(), but is called before constructing + // any frame construction items. Any container frames which need reframing + // regardless of the content inserted or appended can add a check in this + // method. + // + // @return true if we reconstructed the insertion parent frame; false + // otherwise + bool WipeInsertionParent(nsContainerFrame* aFrame); + + // 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); + + void ReframeContainingBlock(nsIFrame* aFrame); + + //---------------------------------------- + + // Methods support :first-letter style + + nsFirstLetterFrame* CreateFloatingLetterFrame( + nsFrameConstructorState& aState, mozilla::dom::Text* aTextContent, + nsIFrame* aTextFrame, nsContainerFrame* aParentFrame, + ComputedStyle* aParentStyle, ComputedStyle* aComputedStyle, + nsFrameList& aResult); + + void CreateLetterFrame(nsContainerFrame* aBlockFrame, + nsContainerFrame* aBlockContinuation, + mozilla::dom::Text* aTextContent, + nsContainerFrame* aParentFrame, nsFrameList& aResult); + + void WrapFramesInFirstLetterFrame(nsContainerFrame* aBlockFrame, + nsFrameList& 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, nsFrameList& aLetterFrames, bool* aStopLooking); + + void RecoverLetterFrames(nsContainerFrame* aBlockFrame); + + void RemoveLetterFrames(PresShell* aPresShell, nsContainerFrame* aBlockFrame); + + // Recursive helper for RemoveLetterFrames + void RemoveFirstLetterFrames(PresShell* aPresShell, nsContainerFrame* aFrame, + nsContainerFrame* aBlockFrame, + bool* aStopLooking); + + // Special remove method for those pesky floating first-letter frames + void RemoveFloatingFirstLetterFrames(PresShell* 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 aFrameList. + // 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 + // aFrameList. In both cases, the kids are reparented to the line frame. + // After this call, aFrameList 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, + nsFrameList& aFrameList); + + // 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, + nsFrameList& aFrameList); + + /** + * When aFrameList is being inserted into aParentFrame, and aParentFrame has + * pseudo-element-affected styles, it's possible that we're inserting under a + * ::first-line frame. In that case, with servo's style system, the styles we + * resolved for aFrameList are wrong (they don't take ::first-line into + * account), and we should fix them up, which is what this method does. + * + * This method does not mutate aFrameList. + */ + void CheckForFirstLineInsertion(nsIFrame* aParentFrame, + nsFrameList& aFrameList); + + /** + * Find the next frame for appending to a given insertion point. + * + * We're appending, so this is almost always null, except for a few edge + * cases. + */ + nsIFrame* FindNextSiblingForAppend(const InsertionPoint&); + + // The direction in which we should look for siblings. + enum class SiblingDirection { + Forward, + Backward, + }; + + /** + * Find the frame for the content immediately next to the one aIter points to, + * in the direction SiblingDirection indicates, following continuations if + * necessary. + * + * aIter is passed by const reference 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 aTargetContentDisplay the CSS display enum for the content aIter + * points to if already known. It will be filled in if needed. + */ + template <SiblingDirection> + nsIFrame* FindSibling( + const mozilla::dom::FlattenedChildIterator& aIter, + mozilla::Maybe<mozilla::StyleDisplay>& aTargetContentDisplay); + + // Helper for the implementation of FindSibling. + // + // Beware that this function does mutate the iterator. + template <SiblingDirection> + nsIFrame* FindSiblingInternal( + mozilla::dom::FlattenedChildIterator&, nsIContent* aTargetContent, + mozilla::Maybe<mozilla::StyleDisplay>& aTargetContentDisplay); + + // An alias of FindSibling<SiblingDirection::Forward>. + nsIFrame* FindNextSibling( + const mozilla::dom::FlattenedChildIterator& aIter, + mozilla::Maybe<mozilla::StyleDisplay>& aTargetContentDisplay); + // An alias of FindSibling<SiblingDirection::Backwards>. + nsIFrame* FindPreviousSibling( + const mozilla::dom::FlattenedChildIterator& aIter, + mozilla::Maybe<mozilla::StyleDisplay>& aTargetContentDisplay); + + // Given a potential first-continuation sibling frame for aTargetContent, + // verify that it is an actual valid sibling for it, and return the + // appropriate continuation the new frame for aTargetContent should be + // inserted next to. + nsIFrame* AdjustSiblingFrame( + nsIFrame* aSibling, nsIContent* aTargetContent, + mozilla::Maybe<mozilla::StyleDisplay>& aTargetContentDisplay, + SiblingDirection aDirection); + + // 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 shadow DOM, 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); + + // 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::Maybe<mozilla::StyleDisplay>& aDisplay); + + void QuotesDirty(); + void CountersDirty(); + + void ConstructAnonymousContentForCanvas(nsFrameConstructorState& aState, + nsContainerFrame* aFrame, + nsIContent* aDocElement, + nsFrameList&); + + public: + friend class nsFrameConstructorState; + + private: + // For allocating FrameConstructionItems from the mFCItemPool arena. + friend struct FrameConstructionItem; + void* AllocateFCItem(); + void FreeFCItem(FrameConstructionItem*); + + mozilla::dom::Document* 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 = nullptr; + // This is the frame for the root element that has no pseudo-element style. + nsIFrame* mRootElementStyleFrame = nullptr; + // This is the containing block that contains the root element --- + // the real "initial containing block" according to CSS 2.1. + nsCanvasFrame* mDocElementContainingBlock = nullptr; + // This is usually mDocElementContainingBlock, except when printing, where it + // is the canvas frame that is under all the printed pages. + nsCanvasFrame* mCanvasFrame = nullptr; + nsPageSequenceFrame* mPageSequenceFrame = nullptr; + + // FrameConstructionItem arena + list of freed items available for re-use. + mozilla::ArenaAllocator<4096, 8> mFCItemPool; + + // This indicates what page name to use for the next nsPageContentFrame. + // Set when CSS named pages cause a breakpoint. + // This does not apply to the first page content frame, which has its name + // set by nsPageContentFrame::EnsurePageName() during first reflow. + RefPtr<const nsAtom> mNextPageContentFramePageName; + + struct FreeFCItemLink { + FreeFCItemLink* mNext; + }; + FreeFCItemLink* mFirstFreeFCItem; + size_t mFCItemsInUse; + + mozilla::ContainStyleScopeManager mContainStyleScopeManager; + + // Current ProcessChildren depth. + uint16_t mCurrentDepth; + bool mQuotesDirty : 1; + bool mCountersDirty : 1; + bool mAlwaysCreateFramesForIgnorableWhitespace : 1; + + // The layout state from our history entry (to restore scroll positions and + // such from history), or a new one if there was none (so we can store scroll + // positions and such during reframe). + // + // FIXME(bug 1397239): This can leak some state sometimes for the lifetime of + // the frame constructor, which is not great. + nsCOMPtr<nsILayoutHistoryState> mFrameTreeState; +}; + +#endif /* nsCSSFrameConstructor_h___ */ |