summaryrefslogtreecommitdiffstats
path: root/layout/base/nsCSSFrameConstructor.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/base/nsCSSFrameConstructor.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/base/nsCSSFrameConstructor.h')
-rw-r--r--layout/base/nsCSSFrameConstructor.h2136
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___ */