--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -4079,21 +4079,18 @@ nsCSSFrameConstructor::ConstructTableCel
return rv;
}
static PRBool
NeedFrameFor(nsIFrame* aParentFrame,
nsIContent* aChildContent)
{
// don't create a whitespace frame if aParentFrame doesn't want it
- if ((NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE & aParentFrame->GetStateBits())
- && TextIsOnlyWhitespace(aChildContent)) {
- return PR_FALSE;
- }
- return PR_TRUE;
+ return !aParentFrame->IsFrameOfType(nsIFrame::eExcludesIgnorableWhitespace) ||
+ !TextIsOnlyWhitespace(aChildContent);
}
const nsStyleDisplay*
nsCSSFrameConstructor::GetDisplay(nsIFrame* aFrame)
{
if (nsnull == aFrame) {
return nsnull;
}
@@ -6858,17 +6855,16 @@ nsCSSFrameConstructor::ConstructMathMLFr
nsFrameItems& aFrameItems,
PRBool aHasPseudoParent)
{
// Make sure that we remain confined in the MathML world
if (aNameSpaceID != kNameSpaceID_MathML)
return NS_OK;
nsresult rv = NS_OK;
- PRBool ignoreInterTagWhitespace = PR_TRUE;
NS_ASSERTION(aTag != nsnull, "null MathML tag");
if (aTag == nsnull)
return NS_OK;
// Initialize the new frame
nsIFrame* newFrame = nsnull;
@@ -6936,20 +6932,18 @@ nsCSSFrameConstructor::ConstructMathMLFr
}
else {
return NS_OK;
}
// If we succeeded in creating a frame then initialize it, process its
// children (if requested), and set the initial child list
if (newFrame) {
- // record that children that are ignorable whitespace should be excluded
- if (ignoreInterTagWhitespace) {
- newFrame->AddStateBits(NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE);
- }
+ NS_ASSERTION(newFrame->IsFrameOfType(nsIFrame::eExcludesIgnorableWhitespace),
+ "Ignorable whitespace should be excluded");
// Only <math> elements can be floated or positioned. All other MathML
// should be in-flow.
PRBool isMath = aTag == nsGkAtoms::math;
nsIFrame* geometricParent =
isMath ? aState.GetGeometricParent(disp, aParentFrame) : aParentFrame;
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -226,22 +226,17 @@ enum {
// If this bit is set, the frame was created from anonymous content.
NS_FRAME_INDEPENDENT_SELECTION = 0x00004000,
// If this bit is set, the frame is "special" (lame term, I know),
// which means that it is part of the mangled frame hierarchy that
// results when an inline has been split because of a nested block.
NS_FRAME_IS_SPECIAL = 0x00008000,
- // If this bit is set, the frame doesn't allow ignorable whitespace as
- // children. For example, the whitespace between <table>\n<tr>\n<td>
- // will be excluded during the construction of children.
- // The bit is set when the frame is first created and remain
- // unchanged during the life-time of the frame.
- NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE = 0x00010000,
+ NS_FRAME_THIS_BIT_BELONGS_TO_ROC_DO_NOT_USE_OR_I_WILL_HUNT_YOU_DOWN = 0x00010000,
#ifdef IBMBIDI
// If this bit is set, the frame itself is a bidi continuation,
// or is incomplete (its next sibling is a bidi continuation)
NS_FRAME_IS_BIDI = 0x00020000,
#endif
// If this bit is set the frame has descendant with a view
@@ -1577,16 +1572,20 @@ public:
// from the outside
eReplacedContainsBlock = 1 << 5,
// A frame that participates in inline reflow, i.e., one that
// requires nsHTMLReflowState::mLineLayout.
eLineParticipant = 1 << 6,
eXULBox = 1 << 7,
eCanContainOverflowContainers = 1 << 8,
eBlockFrame = 1 << 9,
+ // If this bit is set, the frame doesn't allow ignorable whitespace as
+ // children. For example, the whitespace between <table>\n<tr>\n<td>
+ // will be excluded during the construction of children.
+ eExcludesIgnorableWhitespace = 1 << 10,
// These are to allow nsFrame::Init to assert that IsFrameOfType
// implementations all call the base class method. They are only
// meaningful in DEBUG builds.
eDEBUGAllFrames = 1 << 30,
eDEBUGNoFrames = 1 << 31
};
--- a/layout/mathml/base/src/nsMathMLContainerFrame.h
+++ b/layout/mathml/base/src/nsMathMLContainerFrame.h
@@ -106,17 +106,18 @@ public:
SetIncrementScriptLevel(PRInt32 aChildIndex, PRBool aIncrement);
// --------------------------------------------------------------------------
// Overloaded nsHTMLContainerFrame methods -- see documentation in nsIFrame.h
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
return !(aFlags & nsIFrame::eLineParticipant) &&
- nsHTMLContainerFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ nsHTMLContainerFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
virtual PRIntn GetSkipSides() const { return 0; }
NS_IMETHOD
AppendFrames(nsIAtom* aListName,
nsIFrame* aFrameList);
@@ -442,17 +443,18 @@ public:
nsresult rv = nsBlockFrame::RemoveFrame(aListName, aOldFrame);
if (NS_LIKELY(!aListName))
nsMathMLContainerFrame::ReLayoutChildren(this,
NS_FRAME_HAS_DIRTY_CHILDREN);
return rv;
}
virtual PRBool IsFrameOfType(PRUint32 aFlags) const {
- return nsBlockFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsBlockFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
protected:
nsMathMLmathBlockFrame(nsStyleContext* aContext) : nsBlockFrame(aContext) {
// We should always have a space manager. Not that things can really try
// to float out of us anyway, but we need one for line layout.
AddStateBits(NS_BLOCK_SPACE_MGR);
}
@@ -512,17 +514,18 @@ public:
nsresult rv = nsInlineFrame::RemoveFrame(aListName, aOldFrame);
if (NS_LIKELY(!aListName))
nsMathMLContainerFrame::ReLayoutChildren(this,
NS_FRAME_HAS_DIRTY_CHILDREN);
return rv;
}
virtual PRBool IsFrameOfType(PRUint32 aFlags) const {
- return nsInlineFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsInlineFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
protected:
nsMathMLmathInlineFrame(nsStyleContext* aContext) : nsInlineFrame(aContext) {}
virtual ~nsMathMLmathInlineFrame() {}
};
#endif /* nsMathMLContainerFrame_h___ */
--- a/layout/mathml/base/src/nsMathMLmtableFrame.cpp
+++ b/layout/mathml/base/src/nsMathMLmtableFrame.cpp
@@ -842,29 +842,16 @@ NS_NewMathMLmtdInnerFrame(nsIPresShell*
return new (aPresShell) nsMathMLmtdInnerFrame(aContext);
}
nsMathMLmtdInnerFrame::~nsMathMLmtdInnerFrame()
{
}
NS_IMETHODIMP
-nsMathMLmtdInnerFrame::Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow)
-{
- nsresult rv = nsBlockFrame::Init(aContent, aParent, aPrevInFlow);
-
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
- return rv;
-}
-
-NS_IMETHODIMP
nsMathMLmtdInnerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// Let the base class do the reflow
nsresult rv = nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
--- a/layout/mathml/base/src/nsMathMLmtableFrame.h
+++ b/layout/mathml/base/src/nsMathMLmtableFrame.h
@@ -79,17 +79,18 @@ public:
NS_IMETHOD
AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
PRInt32 aModType);
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
- return nsTableOuterFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsTableOuterFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
protected:
nsMathMLmtableOuterFrame(nsStyleContext* aContext) : nsTableOuterFrame(aContext) {}
virtual ~nsMathMLmtableOuterFrame();
// helper to find the row frame at a given index, positive or negative, e.g.,
// 1..n means the first row down to the last row, -1..-n means the last row
@@ -139,17 +140,18 @@ public:
{
nsresult rv = nsTableFrame::RemoveFrame(aListName, aOldFrame);
RestyleTable();
return rv;
}
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
- return nsTableFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsTableFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
// helper to restyle and reflow the table when a row is changed -- since MathML
// attributes are inter-dependent and row/colspan can affect the table, it is
// safer (albeit grossly suboptimal) to just relayout the whole thing.
void RestyleTable();
protected:
@@ -198,17 +200,18 @@ public:
{
nsresult rv = nsTableRowFrame::RemoveFrame(aListName, aOldFrame);
RestyleTable();
return rv;
}
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
- return nsTableRowFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsTableRowFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
// helper to restyle and reflow the table -- @see nsMathMLmtableFrame.
void RestyleTable()
{
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
if (tableFrame && tableFrame->IsFrameOfType(nsIFrame::eMathML)) {
// relayout the table
@@ -236,17 +239,18 @@ public:
AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
PRInt32 aModType);
virtual PRInt32 GetRowSpan();
virtual PRInt32 GetColSpan();
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
- return nsTableCellFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsTableCellFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
protected:
nsMathMLmtdFrame(nsStyleContext* aContext) : nsTableCellFrame(aContext) {}
virtual ~nsMathMLmtdFrame();
}; // class nsMathMLmtdFrame
// --------------
@@ -266,32 +270,26 @@ public:
PRUint32 aFlagsValues,
PRUint32 aFlagsToUpdate)
{
nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(this,
aFirstIndex, aLastIndex, aFlagsValues, aFlagsToUpdate);
return NS_OK;
}
- // overloaded nsBlockFrame methods
-
- NS_IMETHOD
- Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
-
NS_IMETHOD
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
- return nsBlockFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
+ return nsBlockFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
}
protected:
nsMathMLmtdInnerFrame(nsStyleContext* aContext) : nsBlockFrame(aContext) {}
virtual ~nsMathMLmtdInnerFrame();
virtual PRIntn GetSkipSides() const { return 0; }
}; // class nsMathMLmtdInnerFrame
--- a/layout/tables/nsTableColFrame.cpp
+++ b/layout/tables/nsTableColFrame.cpp
@@ -167,30 +167,16 @@ void nsTableColFrame::Dump(PRInt32 aInde
/* ----- global methods ----- */
nsTableColFrame*
NS_NewTableColFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsTableColFrame(aContext);
}
-NS_IMETHODIMP
-nsTableColFrame::Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow)
-{
- // Let the base class do its initialization
- nsresult rv = nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
-
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
- return rv;
-}
-
nsTableColFrame*
nsTableColFrame::GetNextCol() const
{
nsIFrame* childFrame = GetNextSibling();
while (childFrame) {
if (nsGkAtoms::tableColFrame == childFrame->GetType()) {
return (nsTableColFrame*)childFrame;
}
--- a/layout/tables/nsTableColFrame.h
+++ b/layout/tables/nsTableColFrame.h
@@ -71,32 +71,34 @@ public:
nsStyleContext* aContext);
PRInt32 GetColIndex() const;
void SetColIndex (PRInt32 aColIndex);
nsTableColFrame* GetNextCol() const;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
-
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
/**
* Table columns never paint anything, nor receive events.
*/
NS_IMETHOD BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) { return NS_OK; }
+ virtual PRBool IsFrameOfType(PRUint32 aFlags) const
+ {
+ return nsSplittableFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eExcludesIgnorableWhitespace));
+ }
+
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableColFrame
*/
virtual nsIAtom* GetType() const;
#ifdef DEBUG
--- a/layout/tables/nsTableColGroupFrame.cpp
+++ b/layout/tables/nsTableColGroupFrame.cpp
@@ -484,32 +484,16 @@ void nsTableColGroupFrame::GetContinuous
/* ----- global methods ----- */
nsIFrame*
NS_NewTableColGroupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsTableColGroupFrame(aContext);
}
-NS_IMETHODIMP
-nsTableColGroupFrame::Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow)
-{
- nsresult rv;
-
- // Let the base class do its processing
- rv = nsHTMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
-
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
- return rv;
-}
-
nsIAtom*
nsTableColGroupFrame::GetType() const
{
return nsGkAtoms::tableColGroupFrame;
}
#ifdef DEBUG
NS_IMETHODIMP
--- a/layout/tables/nsTableColGroupFrame.h
+++ b/layout/tables/nsTableColGroupFrame.h
@@ -64,23 +64,16 @@ public:
/** instantiate a new instance of nsTableRowFrame.
* @param aPresShell the pres shell for this frame
*
* @return the frame that was created
*/
friend nsIFrame* NS_NewTableColGroupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
- /** sets defaults for the colgroup.
- * @see nsIFrame::Init
- */
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
-
/** Initialize the colgroup frame with a set of children.
* @see nsIFrame::SetInitialChildList
*/
NS_IMETHOD SetInitialChildList(nsIAtom* aListName,
nsIFrame* aChildList);
/**
* ColGroups never paint anything, nor receive events.
@@ -146,16 +139,22 @@ public:
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
/* needed only because we use Reflow in a hacky way, see
nsTableFrame::ReflowColGroups */
virtual PRBool IsContainingBlock() const;
+ virtual PRBool IsFrameOfType(PRUint32 aFlags) const
+ {
+ return nsHTMLContainerFrame::IsFrameOfType(aFlags &
+ ~nsIFrame::eExcludesIgnorableWhitespace);
+ }
+
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableColGroupFrame
*/
virtual nsIAtom* GetType() const;
/** Add column frames to the table storages: colframe cache and cellmap
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -217,19 +217,16 @@ nsTableFrame::Init(nsIContent* aCon
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsresult rv;
// Let the base class do its processing
rv = nsHTMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
// see if border collapse is on, if so set it
const nsStyleTableBorder* tableStyle = GetStyleTableBorder();
PRBool borderCollapse = (NS_STYLE_BORDER_COLLAPSE == tableStyle->mBorderCollapse);
SetBorderCollapse(borderCollapse);
// Create the cell map
if (!aPrevInFlow) {
mCellMap = new nsTableCellMap(*this, borderCollapse);
if (!mCellMap)
--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -367,16 +367,22 @@ public:
nsReflowStatus& aStatus);
nsFrameList& GetColGroups();
NS_IMETHOD GetParentStyleContextFrame(nsPresContext* aPresContext,
nsIFrame** aProviderFrame,
PRBool* aIsChild);
+ virtual PRBool IsFrameOfType(PRUint32 aFlags) const
+ {
+ return nsHTMLContainerFrame::IsFrameOfType(aFlags &
+ ~nsIFrame::eExcludesIgnorableWhitespace);
+ }
+
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableFrame
*/
virtual nsIAtom* GetType() const;
#ifdef DEBUG
--- a/layout/tables/nsTableOuterFrame.cpp
+++ b/layout/tables/nsTableOuterFrame.cpp
@@ -215,30 +215,16 @@ NS_IMETHODIMP nsTableOuterFrame::GetAcce
#endif
/* virtual */ PRBool
nsTableOuterFrame::IsContainingBlock() const
{
return PR_FALSE;
}
-NS_IMETHODIMP
-nsTableOuterFrame::Init(
- nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow)
-{
- nsresult rv = nsHTMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
-
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
- return rv;
-}
-
void
nsTableOuterFrame::Destroy()
{
mCaptionFrames.DestroyFrames();
nsHTMLContainerFrame::Destroy();
}
nsIFrame*
--- a/layout/tables/nsTableOuterFrame.h
+++ b/layout/tables/nsTableOuterFrame.h
@@ -94,22 +94,24 @@ public:
* @param aPresShell the pres shell for this frame
*
* @return the frame that was created
*/
friend nsIFrame* NS_NewTableOuterFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
// nsIFrame overrides - see there for a description
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
-
virtual void Destroy();
+ virtual PRBool IsFrameOfType(PRUint32 aFlags) const
+ {
+ return nsHTMLContainerFrame::IsFrameOfType(aFlags &
+ ~nsIFrame::eExcludesIgnorableWhitespace);
+ }
+
virtual PRBool IsContainingBlock() const;
NS_IMETHOD SetInitialChildList(nsIAtom* aListName,
nsIFrame* aChildList);
virtual nsIFrame* GetFirstChild(nsIAtom* aListName) const;
virtual nsIAtom* GetAdditionalChildListName(PRInt32 aIndex) const;
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -159,19 +159,16 @@ nsTableRowFrame::Init(nsIContent* a
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsresult rv;
// Let the base class do its initialization
rv = nsHTMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
if (aPrevInFlow) {
// Set the row index
nsTableRowFrame* rowFrame = (nsTableRowFrame*)aPrevInFlow;
SetRowIndex(rowFrame->GetRowIndex());
}
return rv;
--- a/layout/tables/nsTableRowFrame.h
+++ b/layout/tables/nsTableRowFrame.h
@@ -113,16 +113,22 @@ public:
*/
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
void DidResize();
+ virtual PRBool IsFrameOfType(PRUint32 aFlags) const
+ {
+ return nsHTMLContainerFrame::IsFrameOfType(aFlags &
+ ~nsIFrame::eExcludesIgnorableWhitespace);
+ }
+
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableRowFrame
*/
virtual nsIAtom* GetType() const;
#ifdef DEBUG
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -1582,30 +1582,16 @@ nsTableRowGroupFrame::GetType() const
/* ----- global methods ----- */
nsIFrame*
NS_NewTableRowGroupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsTableRowGroupFrame(aContext);
}
-NS_IMETHODIMP
-nsTableRowGroupFrame::Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow)
-{
- // Let the base class do its processing
- nsresult rv = nsHTMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
-
- // record that children that are ignorable whitespace should be excluded
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
- return rv;
-}
-
#ifdef DEBUG
NS_IMETHODIMP
nsTableRowGroupFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("TableRowGroup"), aResult);
}
#endif
--- a/layout/tables/nsTableRowGroupFrame.h
+++ b/layout/tables/nsTableRowGroupFrame.h
@@ -104,20 +104,16 @@ public:
/** instantiate a new instance of nsTableRowFrame.
* @param aPresShell the pres shell for this frame
*
* @return the frame that was created
*/
friend nsIFrame* NS_NewTableRowGroupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
virtual ~nsTableRowGroupFrame();
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
-
NS_IMETHOD AppendFrames(nsIAtom* aListName,
nsIFrame* aFrameList);
NS_IMETHOD InsertFrames(nsIAtom* aListName,
nsIFrame* aPrevFrame,
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
@@ -140,16 +136,22 @@ public:
*
* @see nsIFrame::Reflow
*/
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
+ virtual PRBool IsFrameOfType(PRUint32 aFlags) const
+ {
+ return nsHTMLContainerFrame::IsFrameOfType(aFlags &
+ ~nsIFrame::eExcludesIgnorableWhitespace);
+ }
+
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableRowGroupFrame
*/
virtual nsIAtom* GetType() const;
virtual PRBool IsContainingBlock() const;
--- a/layout/xul/base/src/nsBoxFrame.cpp
+++ b/layout/xul/base/src/nsBoxFrame.cpp
@@ -195,23 +195,16 @@ nsBoxFrame::DidSetStyleContext()
NS_IMETHODIMP
nsBoxFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsresult rv = nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
NS_ENSURE_SUCCESS(rv, rv);
- // record that children that are ignorable whitespace should be excluded
- // (When content was loaded via the XUL content sink, it's already
- // been excluded, but we need this for when the XUL namespace is used
- // in other MIME types or when the XUL CSS display types are used with
- // non-XUL elements.)
- mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
-
MarkIntrinsicWidthsDirty();
// see if we need a widget
if (aParent && aParent->IsBoxFrame()) {
if (aParent->ChildrenMustHaveWidgets()) {
rv = nsHTMLContainerFrame::CreateViewForFrame(this, nsnull, PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
--- a/layout/xul/base/src/nsBoxFrame.h
+++ b/layout/xul/base/src/nsBoxFrame.h
@@ -140,22 +140,29 @@ public:
nsIFrame* aChildList);
NS_IMETHOD DidSetStyleContext();
virtual nsIAtom* GetType() const;
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
+ // record that children that are ignorable whitespace should be excluded
+ // (When content was loaded via the XUL content sink, it's already
+ // been excluded, but we need this for when the XUL namespace is used
+ // in other MIME types or when the XUL CSS display types are used with
+ // non-XUL elements.)
+
// This is bogus, but it's what we've always done.
// (Given that we're replaced, we need to say we're a replaced element
// that contains a block so nsHTMLReflowState doesn't tell us to be
// NS_INTRINSICSIZE wide.)
return nsContainerFrame::IsFrameOfType(aFlags &
- ~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock | eXULBox));
+ ~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock | eXULBox |
+ nsIFrame::eExcludesIgnorableWhitespace));
}
#ifdef DEBUG
NS_IMETHOD GetFrameName(nsAString& aResult) const;
#endif
NS_IMETHOD DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
--- a/nsprpub/configure
+++ b/nsprpub/configure
@@ -6092,17 +6092,17 @@ trap 'rm -f $CONFIG_STATUS conftest*; ex
# Protect against Makefile macro expansion.
cat > conftest.defs <<\EOF
s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%-D\1=\2%g
s%[ `~#$^&*(){}\\|;'"<>?]%\\&%g
s%\[%\\&%g
s%\]%\\&%g
s%\$%$$%g
EOF
-DEFS=`sed -f conftest.defs confdefs.h | tr '\012' ' ' | tr '\015' ' '`
+DEFS=`sed -f conftest.defs confdefs.h | tr '\012' ' '`
rm -f conftest.defs
# Without the "./", some shells look in PATH for config.status.
: ${CONFIG_STATUS=./config.status}
echo creating $CONFIG_STATUS
rm -f $CONFIG_STATUS