Bug 484448. Fix handling of whitespace kids of table-related frames. r=bernd, sr=roc

--HG--
rename : layout/reftests/table-anonymous-boxes/white-space-1.html => layout/reftests/table-anonymous-boxes/white-space-7.html

content/base/src/nsGenericDOMDataNode.cpp

@@ -585,6 +585,10 @@ nsGenericDOMDataNode::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
 void
 nsGenericDOMDataNode::UnbindFromTree(PRBool aDeep, PRBool aNullParent)
 {
+  // Unset FRAMETREE_DEPENDS_ON_CHARS; if we need it again later, it'll get set
+  // again.
+  UnsetFlags(FRAMETREE_DEPENDS_ON_CHARS);
+  
   nsIDocument *document = GetCurrentDoc();
   if (document) {
     // Notify XBL- & nsIAnonymousContentCreator-generated

content/base/src/nsGenericDOMDataNode.h

@@ -43,6 +43,9 @@
 #ifndef nsGenericDOMDataNode_h___
 #define nsGenericDOMDataNode_h___
 
+// This bit is set if the frame tree depends on whether this node is whitespace
+#define FRAMETREE_DEPENDS_ON_CHARS (1 << NODE_TYPE_SPECIFIC_BITS_OFFSET)
+
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMEventTarget.h"
 #include "nsIDOM3Text.h"

layout/base/nsCSSFrameConstructor.cpp

@@ -122,6 +122,7 @@
 #include "nsIFocusEventSuppressor.h"
 #include "nsBox.h"
 #include "nsTArray.h"
+#include "nsGenericDOMDataNode.h"
 
 #ifdef MOZ_XUL
 #include "nsIRootBox.h"
@@ -1923,13 +1924,6 @@ nsCSSFrameConstructor::CreateGeneratedContentItem(nsFrameConstructorState& aStat
                                     kNameSpaceID_None, pseudoStyleContext,
                                     ITEM_IS_GENERATED_CONTENT, aItems);
 }
-
-static PRBool
-TextIsOnlyWhitespace(nsIContent* aContent)
-{
-  return aContent->IsNodeOfType(nsINode::eTEXT) &&
-         aContent->TextIsOnlyWhitespace();
-}
     
 /****************************************************
  **  BEGIN TABLE SECTION
@@ -2374,9 +2368,21 @@ NeedFrameFor(nsIFrame*   aParentFrame,
   // want to be reconstructing frames. It's not even clear that these
   // should be considered ignorable just because they evaluate to
   // whitespace.
-  return !aParentFrame->IsFrameOfType(nsIFrame::eExcludesIgnorableWhitespace)
-    || !TextIsOnlyWhitespace(aChildContent)
-    || aParentFrame->IsGeneratedContentFrame();
+
+  // We could handle all this in CreateNeededTablePseudos or some other place
+  // after we build our frame construction items, but that would involve
+  // creating frame construction items for whitespace kids of
+  // eExcludesIgnorableWhitespace frames, where we know we'll be dropping them
+  // all anyway, and involve an extra walk down the frame construction item
+  // list.
+  if (!aParentFrame->IsFrameOfType(nsIFrame::eExcludesIgnorableWhitespace) ||
+      aParentFrame->IsGeneratedContentFrame() ||
+      !aChildContent->IsNodeOfType(nsINode::eTEXT)) {
+    return PR_TRUE;
+  }
+
+  aChildContent->SetFlags(FRAMETREE_DEPENDS_ON_CHARS);
+  return !aChildContent->TextIsOnlyWhitespace();
 }
 
 /***********************************************
@@ -6682,7 +6688,11 @@ nsCSSFrameConstructor::ContentInserted(nsIContent*            aContainer,
   // when neither parent is a special frame and should not affect whitespace
   // handling inside table-related frames (and in fact, can only happen when
   // one of the parents is an outer table and one is an inner table or when the
-  // parent is a fieldset or fieldset content frame).
+  // parent is a fieldset or fieldset content frame).  So it won't affect the
+  // {ib} or XUL box cases in WipeContainingBlock(), and the table pseudo
+  // handling will only be affected by us maybe thinking we're not inserting
+  // at the beginning, whereas we really are.  That would have made us reframe
+  // unnecessarily, but that's ok.
   // XXXbz we should push our frame construction item code up higher, so we
   // know what our items are by the time we start figuring out previous
   // siblings
@@ -7480,6 +7490,15 @@ nsCSSFrameConstructor::CharacterDataChanged(nsIContent* aContent,
   AUTO_LAYOUT_PHASE_ENTRY_POINT(mPresShell->GetPresContext(), FrameC);
   nsresult      rv = NS_OK;
 
+  if (aContent->HasFlag(FRAMETREE_DEPENDS_ON_CHARS)) {
+#ifdef DEBUG
+    nsIFrame* frame = mPresShell->GetPrimaryFrameFor(aContent);
+    NS_ASSERTION(!frame || !frame->IsGeneratedContentFrame(),
+                 "Bit should never be set on generated content");
+#endif
+    return RecreateFramesForContent(aContent);
+  }
+
   // Find the child frame
   nsIFrame* frame = mPresShell->GetPrimaryFrameFor(aContent);
 
@@ -8736,6 +8755,28 @@ nsCSSFrameConstructor::MaybeRecreateFramesForContent(nsIContent* aContent)
   return result;
 }
 
+static nsIFrame*
+FindFirstNonWhitespaceChild(nsIFrame* aParentFrame)
+{
+  nsIFrame* f = aParentFrame->GetFirstChild(nsnull);
+  while (f && f->GetType() == nsGkAtoms::textFrame &&
+         f->GetContent()->TextIsOnlyWhitespace()) {
+    f = f->GetNextSibling();
+  }
+  return f;
+}
+
+static nsIFrame*
+FindNextNonWhitespaceSibling(nsIFrame* aFrame)
+{
+  nsIFrame* f = aFrame;
+  do {
+    f = f->GetNextSibling();
+  } while (f && f->GetType() == nsGkAtoms::textFrame &&
+           f->GetContent()->TextIsOnlyWhitespace());
+  return f;
+}
+
 PRBool
 nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame,
                                                              nsresult* aResult)
@@ -8769,8 +8810,8 @@ nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame,
   NS_ASSERTION(inFlowFrame, "How did that happen?");
   nsIFrame* parent = inFlowFrame->GetParent();
   if (IsTablePseudo(parent)) {
-    if (parent->GetFirstChild(nsnull) == inFlowFrame ||
-        !inFlowFrame->GetLastContinuation()->GetNextSibling() ||
+    if (FindFirstNonWhitespaceChild(parent) == inFlowFrame ||
+        !FindNextNonWhitespaceSibling(inFlowFrame->GetLastContinuation()) ||
         // If we're a table-column-group, then the GetFirstChild check above is
         // not going to catch cases when we're the first child.
         (inFlowFrame->GetType() == nsGkAtoms::tableColGroupFrame &&
@@ -9082,107 +9123,104 @@ nsCSSFrameConstructor::CreateNeededTablePseudos(FrameConstructionItemList& aItem
 
   FCItemIterator iter(aItems);
   do {
-    NS_ASSERTION(!iter.IsDone(), "How did that happen?");
-
-    // Advance to the next item that wants a different parent type.
-    while (iter.item().DesiredParentType() == ourParentType) {
-      iter.Next();
-      if (iter.IsDone()) {
-        // Nothing else to do here; we're finished
-        return NS_OK;
-      }
+    if (iter.SkipItemsWantingParentType(ourParentType)) {
+      // Nothing else to do here; we're finished
+      return NS_OK;
     }
 
-    NS_ASSERTION(!iter.IsDone() &&
-                 iter.item().DesiredParentType() != ourParentType,
-                 "Why did we stop?");
-
     // Now we're pointing to the first child that wants a different parent
-    // type.  Except for generated content, we should have already enforced the
-    // fact that no such items are whitespace (either in this method when
-    // constructing wrapping items, or when constructing the original
-    // FrameConstructionItemList).
-    NS_ASSERTION(aParentFrame->IsGeneratedContentFrame() ||
-                 !iter.item().mIsText ||
-                 !iter.item().mContent->TextIsOnlyWhitespace(),
-                 "Why do we have whitespace under a known-table parent?");
+    // type.
 
     // Now try to figure out what kids we can group together.  We can generally
     // group everything that has a different desired parent type from us.  Two
     // exceptions to this:
     // 1) If our parent type is table, we can't group columns with anything
     //    else other than whitespace.
-    // 2) Whitespace that lies between two things we can group should
-    //    be dropped, even if we can't group them with each other.
-    // XXXbz it's not clear to me that rule 2 is a good one, it's not called
-    // for by the (admittedly vague) spec, and in fact it leads to some pretty
-    // crappy behavior if you have some inlines and whitespace as kids of a
-    // table-row, say, but it's more or less what we used to do.  More
-    // precisely, we shipped all whitespace out to the nearest block parent of
-    // the whole mess, sort of.  In any case this aspect of things, and in fact
-    // this whole function might need changes as the spec here gets
-    // clarified...  I happen to think we should not drop whitespace that comes
-    // between things that want a block parent.
+    // 2) Whitespace that lies between two things we can group which both want
+    //    a non-block parent should be dropped, even if we can't group them
+    //    with each other and even if the whitespace wants a parent of
+    //    ourParentType.  Ends of the list count as things that don't want a
+    //    block parent (so that for example we'll drop a whitespace-only list).
 
     FCItemIterator endIter(iter); /* iterator to find the end of the group */
     ParentType groupingParentType = endIter.item().DesiredParentType();
-    // If we decide to, we could optimize this by checking whether
-    // aItems.AllWantParentType(groupingParentType) and if so just setting
-    // endIter to the end of the list, which is an O(1) operation.  That
-    // requires not dropping whitespace between items that want a block parent,
-    // though, per the XXX comment above, since a whole bunch of spans and
-    // whitespace would test true to all wanting a block parent.
-    do {
-      endIter.Next();
-      if (endIter.IsDone()) {
-        break;
-      }
+    if (aItems.AllWantParentType(groupingParentType) &&
+        groupingParentType != eTypeBlock) {
+      // Just group them all and be done with it.  We need the check for
+      // eTypeBlock here to catch the "all the items are whitespace" case
+      // described above.
+      endIter.SetToEnd();
+    } else {
+      // Locate the end of the group.
 
-      if (!aParentFrame->IsGeneratedContentFrame() &&
-          endIter.item().IsWhitespace()) {
-        // Whitespace coming after some groupable items
-        FCItemIterator textSkipIter(endIter);
-        do {
-          textSkipIter.Next();
-        } while (!textSkipIter.IsDone() && textSkipIter.item().IsWhitespace());
+      // Keep track of the type the previous item wanted, in case we have to
+      // deal with whitespace.  Start it off with ourParentType, since that's
+      // the last thing |iter| would have skipped over.
+      ParentType prevParentType = ourParentType;
+      do {
+        /* Walk an iterator past any whitespace that we might be able to drop from the list */
+        FCItemIterator spaceEndIter(endIter);
+        if (prevParentType != eTypeBlock &&
+            !aParentFrame->IsGeneratedContentFrame() &&
+            spaceEndIter.item().IsWhitespace()) {
+          PRBool trailingSpaces = spaceEndIter.SkipWhitespace();
 
-        PRBool trailingSpace = textSkipIter.IsDone();
-        if (// Trailing whitespace we can't handle
-            (trailingSpace && ourParentType != eTypeBlock) ||
-            // Whitespace before kids needing wrapping
-            (!trailingSpace &&
-             textSkipIter.item().DesiredParentType() != ourParentType)) {
-          // Drop all the whitespace here so that |endIter| now points to the
-          // same thing as |textSkipIter|.  This doesn't affect where |iter|
-          // points, since that's guaranted to point to before endIter.
-          do {
-            endIter.DeleteItem();
-          } while (endIter != textSkipIter);
+          // See whether we can drop the whitespace
+          if (trailingSpaces ||
+              spaceEndIter.item().DesiredParentType() != eTypeBlock) {
+            PRBool updateStart = (iter == endIter);
+            endIter.DeleteItemsTo(spaceEndIter);
+            NS_ASSERTION(trailingSpaces == endIter.IsDone(), "These should match");
 
-          NS_ASSERTION(endIter.IsDone() == trailingSpace,
-                       "endIter == skipIter now!");
-          if (trailingSpace) {
-            break; // The loop advancing endIter
+            if (updateStart) {
+              iter = endIter;
+            }
+
+            if (trailingSpaces) {
+              break; /* Found group end */
+            }
+
+            if (updateStart) {
+              // Update groupingParentType, since it might have been eTypeBlock
+              // just because of the whitespace.
+              groupingParentType = iter.item().DesiredParentType();
+            }
           }
         }
-      }
 
-      ParentType itemParentType = endIter.item().DesiredParentType();
+        // Now endIter points to a non-whitespace item or a non-droppable
+        // whitespace item. In the latter case, if this is the end of the group
+        // we'll traverse this whitespace again.  But it'll all just be quick
+        // DesiredParentType() checks which will match ourParentType (that's
+        // what it means that this is the group end), so it's OK.
+        prevParentType = endIter.item().DesiredParentType();
+        if (prevParentType == ourParentType) {
+          // End the group at endIter.
+          break;
+        }
 
-      if (itemParentType == ourParentType) {
-        break;
-      }
+        if (ourParentType == eTypeTable &&
+            (prevParentType == eTypeColGroup) !=
+            (groupingParentType == eTypeColGroup)) {
+          // Either we started with columns and now found something else, or vice
+          // versa.  In any case, end the grouping.
+          break;
+        }
 
-      if (ourParentType == eTypeTable &&
-          (itemParentType == eTypeColGroup) !=
-          (groupingParentType == eTypeColGroup)) {
-        // Either we started with columns and now found something else, or vice
-        // versa.  In any case, end the grouping.
-        break;
-      }
-    } while (1);
+        // Include the whitespace we didn't drop (if any) in the group, since
+        // this is not the end of the group.  Note that this doesn't change
+        // prevParentType, since if we didn't drop the whitespace then we ended
+        // at something that wants a block parent.
+        endIter = spaceEndIter;
 
-    NS_ASSERTION(iter != endIter, "How did that happen?");
+        endIter.Next();
+      } while (!endIter.IsDone());
+    }
+
+    if (iter == endIter) {
+      // Nothing to wrap here; just skipped some whitespace
+      continue;
+    }
 
     // Now group together all the items between iter and endIter.  The right
     // parent type to use depends on ourParentType.
@@ -10798,7 +10836,7 @@ PRBool
 nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
                                            nsIFrame* aContainingBlock,
                                            nsIFrame* aFrame,
-                                           const FrameConstructionItemList& aItems,
+                                           FrameConstructionItemList& aItems,
                                            PRBool aIsAppend,
                                            nsIFrame* aPrevSibling)
 {
@@ -10818,6 +10856,8 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
     return PR_TRUE;
   }
 
+  nsIFrame* nextSibling = ::GetInsertNextSibling(aFrame, aPrevSibling);
+
   // Situation #2 is a case when table pseudo-frames don't work out right
   ParentType parentType = GetParentType(aFrame);
   // If all the kids want a parent of the type that aFrame is, then we're all
@@ -10827,6 +10867,90 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
   // table pseudo-frame, then all the kids in this list would have wanted a
   // frame of that type wrapping them anyway, so putting them inside it is ok.
   if (!aItems.AllWantParentType(parentType)) {
+    // Don't give up yet.  If parentType is not eTypeBlock and the parent is
+    // not a generated content frame, then try filtering whitespace out of the
+    // list.
+    if (parentType != eTypeBlock && !aFrame->IsGeneratedContentFrame()) {
+      // For leading whitespace followed by a kid that wants our parent type,
+      // there are four cases:
+      // 1) We have a previous sibling which is not a table pseudo.  That means
+      //    that previous sibling wanted a (non-block) parent of the type we're
+      //    looking at.  Then the whitespace comes between two table-internal
+      //    elements, so should be collapsed out.
+      // 2) We have a previous sibling which is a table pseudo.  It might have
+      //    kids who want this whitespace, so we need to reframe.
+      // 3) We have no previous sibling and our parent either has a previous
+      //    continuation or is a table pseudo.  This might not be a real insert
+      //    at the beginning, then.  We need to reframe.
+      // 4) We have no previous sibling and our parent frame is its own first
+      //    continuation and is not a table pseudo.  That means that we'll be
+      //    at the beginning of our actual non-block-type parent, and the
+      //    whitespace is OK to collapse out.  If something is ever inserted
+      //    before us, it'll find our own parent as its parent and if it's
+      //    something that would care about the whitespace it'll want a block
+      //    parent, so it'll trigger a reframe at that point.
+      //
+      // It's always OK to drop whitespace between any two items that want a
+      // parent of type parentType.
+      //
+      // For trailing whitespace, the situation is more complicated.  We might
+      // in fact have a next sibling that would care about the whitespace.  We
+      // just don't know anything about that here.  So leave trailing
+      // whitespace be, unless aIsAppend is true and we have no nextSibling.
+      // In that case, we have no next sibling, and if one ever gets added that
+      // would care about the whitespace it'll get us as a previous sibling and
+      // trigger a reframe.  Note that we do need to look at aIsAppend, unless
+      // we want to look at aFrame's next continuation and whether aFrame is a
+      // table pseudo or some such.  But that would be more annoying if we want
+      // to handle XHTML <tr> inside <table> with no table-row-groups around
+      // efficiently.
+      FCItemIterator iter(aItems);
+      FCItemIterator start(iter);
+      do {
+        if (iter.SkipItemsWantingParentType(parentType)) {
+          break;
+        }
+
+        // iter points to an item that wants a different parent.  If it's not
+        // whitespace, we're done; no more point scanning the list.
+        if (!iter.item().IsWhitespace()) {
+          break;
+        }
+
+        if (iter == start) {
+          // Leading whitespace.  How to handle this depends on aPrevSibling
+          // and aFrame.  See the long comment above.
+          if (aPrevSibling) {
+            if (IsTablePseudo(aPrevSibling)) {
+              // need to reframe
+              break;
+            }
+          } else if (aFrame->GetPrevContinuation() || IsTablePseudo(aFrame)) {
+            // need to reframe
+            break;
+          }
+        }
+
+        FCItemIterator spaceEndIter(iter);
+        // Advance spaceEndIter past any whitespace
+        PRBool trailingSpaces = spaceEndIter.SkipWhitespace();
+
+        if ((!trailingSpaces &&
+             spaceEndIter.item().DesiredParentType() == parentType) ||
+            (trailingSpaces && aIsAppend && !nextSibling)) {
+          // Drop the whitespace
+          iter.DeleteItemsTo(spaceEndIter);
+        } else {
+          // We're done: we don't want to drop the whitespace, and it has the
+          // wrong parent type.
+          break;
+        }
+
+        // Now loop, since |iter| points to item right after the whitespace we
+        // removed.
+      } while (!iter.IsDone());
+    }
+
     // We might be able to figure out some sort of optimizations here, but they
     // would have to depend on having a correct aPrevSibling and a correct next
     // sibling.  For example, we can probably avoid reframing if none of
@@ -10835,10 +10959,18 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
     // in fact do not have a reliable aPrevSibling, nor any next sibling, in
     // this method.
 
-    // Reframing aFrame->GetContent() is good enough, since the content of
-    // table pseudo-frames is the ancestor content.
-    RecreateFramesForContent(aFrame->GetContent());
-    return PR_TRUE;
+    // aItems might have changed, so recheck the parent type thing.  In fact,
+    // it might be empty, so recheck that too.
+    if (aItems.IsEmpty()) {
+      return PR_FALSE;
+    }
+
+    if (!aItems.AllWantParentType(parentType)) {
+      // Reframing aFrame->GetContent() is good enough, since the content of
+      // table pseudo-frames is the ancestor content.
+      RecreateFramesForContent(aFrame->GetContent());
+      return PR_TRUE;
+    }
   }
 
   // Situation #3 is an inline frame that will now contain block
@@ -10865,7 +10997,6 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
     // messing up either end of it.
     if (aPrevSibling || !aItems.IsStartInline()) {
       // Not messing up the beginning.  Now let's look at the end.
-      nsIFrame* nextSibling = ::GetInsertNextSibling(aFrame, aPrevSibling);
       if (nextSibling) {
         // Can't possibly screw up the end; bail out
         return PR_FALSE;
@@ -11563,6 +11694,19 @@ nsCSSFrameConstructor::LazyGenerateChildrenEvent::Run()
   return NS_OK;
 }
 
+//////////////////////////////////////////////////////////
+// nsCSSFrameConstructor::FrameConstructionItem methods //
+//////////////////////////////////////////////////////////
+PRBool
+nsCSSFrameConstructor::FrameConstructionItem::IsWhitespace() const
+{
+  if (!mIsText) {
+    return PR_FALSE;
+  }
+  mContent->SetFlags(FRAMETREE_DEPENDS_ON_CHARS);
+  return mContent->TextIsOnlyWhitespace();
+}
+
 //////////////////////////////////////////////////////////////
 // nsCSSFrameConstructor::FrameConstructionItemList methods //
 //////////////////////////////////////////////////////////////
@@ -11584,6 +11728,36 @@ AdjustCountsForItem(FrameConstructionItem* aItem, PRInt32 aDelta)
 ////////////////////////////////////////////////////////////////////////
 // nsCSSFrameConstructor::FrameConstructionItemList::Iterator methods //
 ////////////////////////////////////////////////////////////////////////
+inline PRBool
+nsCSSFrameConstructor::FrameConstructionItemList::
+Iterator::SkipItemsWantingParentType(ParentType aParentType)
+{
+  NS_PRECONDITION(!IsDone(), "Shouldn't be done yet");
+  while (item().DesiredParentType() == aParentType) {
+    Next();
+    if (IsDone()) {
+      return PR_TRUE;
+    }
+  }
+  return PR_FALSE;
+}
+
+inline PRBool
+nsCSSFrameConstructor::FrameConstructionItemList::
+Iterator::SkipWhitespace()
+{
+  NS_PRECONDITION(!IsDone(), "Shouldn't be done yet");
+  NS_PRECONDITION(item().IsWhitespace(), "Not pointing to whitespace?");
+  do {
+    Next();
+    if (IsDone()) {
+      return PR_TRUE;
+    }
+  } while (item().IsWhitespace());
+
+  return PR_FALSE;
+}
+
 void
 nsCSSFrameConstructor::FrameConstructionItemList::
 Iterator::AppendItemToList(FrameConstructionItemList& aTargetList)
@@ -11646,11 +11820,18 @@ Iterator::InsertItem(FrameConstructionItem* aItem)
 }
 
 void
-nsCSSFrameConstructor::FrameConstructionItemList::Iterator::DeleteItem()
+nsCSSFrameConstructor::FrameConstructionItemList::
+Iterator::DeleteItemsTo(const Iterator& aEnd)
 {
-  FrameConstructionItem* item = ToItem(mCurrent);
-  Next();
-  PR_REMOVE_LINK(item);
-  mList.AdjustCountsForItem(item, -1);
-  delete item;
+  NS_PRECONDITION(mEnd == aEnd.mEnd, "end iterator for some other list?");
+  NS_PRECONDITION(*this != aEnd, "Shouldn't be at aEnd yet");
+
+  do {
+    NS_ASSERTION(!IsDone(), "Ran off end of list?");
+    FrameConstructionItem* item = ToItem(mCurrent);
+    Next();
+    PR_REMOVE_LINK(item);
+    mList.AdjustCountsForItem(item, -1);
+    delete item;
+  } while (*this != aEnd);
 }

layout/base/nsCSSFrameConstructor.h

@@ -748,6 +748,11 @@ private:
       PRBool operator!=(const Iterator& aOther) const {
         return !(*this == aOther);
       }
+      Iterator& operator=(const Iterator& aOther) {
+        NS_ASSERTION(mEnd == aOther.mEnd, "Iterators for different lists?");
+        mCurrent = aOther.mCurrent;
+        return *this;
+      }
 
       operator FrameConstructionItem& () {
         return item();
@@ -762,6 +767,17 @@ private:
         NS_ASSERTION(!IsDone(), "Should have checked IsDone()!");
         mCurrent = PR_NEXT_LINK(mCurrent);
       }
+      void SetToEnd() { mCurrent = mEnd; }
+
+      // 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 PRBool SkipItemsWantingParentType(ParentType aParentType);
+
+      // 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 PRBool SkipWhitespace();
 
       // 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
@@ -785,9 +801,12 @@ private:
       // case this call just appends the given item to the list.
       void InsertItem(FrameConstructionItem* aItem);
 
-      // Delete the item pointed to by this iterator, and point ourselves to
-      // the next item in the list.
-      void DeleteItem();
+      // 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:
       PRCList* mCurrent;
@@ -841,9 +860,11 @@ private:
     ParentType DesiredParentType() {
       return FCDATA_DESIRED_PARENT_TYPE(mFCData->mBits);
     }
-    PRBool IsWhitespace() const {
-      return mIsText && mContent->TextIsOnlyWhitespace();
-    }
+
+    // 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.
+    PRBool IsWhitespace() const;
 
     // The FrameConstructionData to use.
     const FrameConstructionData* mFCData;
@@ -1355,7 +1376,7 @@ private:
   PRBool WipeContainingBlock(nsFrameConstructorState& aState,
                              nsIFrame*                aContainingBlock,
                              nsIFrame*                aFrame,
-                             const FrameConstructionItemList& aItems,
+                             FrameConstructionItemList& aItems,
                              PRBool                   aIsAppend,
                              nsIFrame*                aPrevSibling);
 

layout/generic/nsTextFrameThebes.cpp

@@ -3422,6 +3422,8 @@ nsTextFrame::Init(nsIContent*      aContent,
 void
 nsTextFrame::Destroy()
 {
+  // We might want to clear FRAMETREE_DEPENDS_ON_CHARS on mContent here, since
+  // our parent frame type might be changing.  Not clear whether it's worth it.
   ClearTextRun();
   if (mNextContinuation) {
     mNextContinuation->SetPrevInFlow(nsnull);

layout/mathml/nsMathMLmtableFrame.h

@@ -84,8 +84,7 @@ public:
 
   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
   {
-    return nsTableOuterFrame::IsFrameOfType(aFlags &
-      ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
+    return nsTableOuterFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
   }
 
 protected:
@@ -143,8 +142,7 @@ public:
 
   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
   {
-    return nsTableFrame::IsFrameOfType(aFlags &
-      ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
+    return nsTableFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
   }
 
   // helper to restyle and reflow the table when a row is changed -- since MathML
@@ -201,8 +199,7 @@ public:
 
   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
   {
-    return nsTableRowFrame::IsFrameOfType(aFlags &
-      ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
+    return nsTableRowFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
   }
 
   // helper to restyle and reflow the table -- @see nsMathMLmtableFrame.
@@ -238,8 +235,7 @@ public:
   virtual PRInt32 GetColSpan();
   virtual PRBool IsFrameOfType(PRUint32 aFlags) const
   {
-    return nsTableCellFrame::IsFrameOfType(aFlags &
-      ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
+    return nsTableCellFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
   }
 
 protected:

layout/reftests/table-anonymous-boxes/3-blocks-ref.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <body style="font-family: monospace">
+    <div>
+      Row 1, Col 1Row 1, Col 2Row 1, Col 3
+    </div>
+    <div>
+      Row 22, Col 1Row 22, Col 2Row 22, Col 3
+    </div>
+    <div>
+      Row 333, Col 1Row 333, Col 2Row 333, Col 3
+    </div>    
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/3-tables-ref.html

@@ -1,21 +1,21 @@
 <!DOCTYPE html>
 <html>
   <body style="font-family: monospace">
-    <table cellpadding="0" cellspacing="0">
+    <table cellpadding="0" cellspacing="0" style="margin: 0; padding: 0; border: none">
       <tr>
         <td>Row 1, Col 1</td>
         <td>Row 1, Col 2</td>
         <td>Row 1, Col 3</td>
       </tr>
     </table>
-    <table cellpadding="0" cellspacing="0">
+    <table cellpadding="0" cellspacing="0" style="margin: 0; padding: 0; border: none">
       <tr>
         <td>Row 22, Col 1</td>
         <td>Row 22, Col 2</td>
         <td>Row 22, Col 3</td>
       </tr>
     </table>
-    <table cellpadding="0" cellspacing="0">
+    <table cellpadding="0" cellspacing="0" style="margin: 0; padding: 0; border: none">
       <tr>
         <td>Row 333, Col 1</td>
         <td>Row 333, Col 2</td>

layout/reftests/table-anonymous-boxes/372641-1-ref.xhtml

@@ -0,0 +1,10 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+</head>
+
+<body>
+
+<table border="1"><tbody><tr><td>TD</td></tr></tbody></table>
+
+</body>
+</html>

layout/reftests/table-anonymous-boxes/372641-1a.xhtml

@@ -0,0 +1,15 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+</head>
+
+<body>
+
+<table border="1" id="table">XXX<tbody><tr><td>TD</td></tr></tbody></table>
+
+<script>
+document.body.offsetWidth;
+document.getElementById("table").firstChild.data = '';
+</script>
+
+</body>
+</html>

layout/reftests/table-anonymous-boxes/372641-1b.xhtml

@@ -0,0 +1,15 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+</head>
+
+<body>
+
+<table border="1"><tbody id="tbody">XXX<tr><td>TD</td></tr></tbody></table>
+
+<script>
+document.body.offsetWidth;
+document.getElementById("tbody").firstChild.data = '';
+</script>
+
+</body>
+</html>

layout/reftests/table-anonymous-boxes/372641-1c.xhtml

@@ -0,0 +1,15 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+</head>
+
+<body>
+
+<table border="1"><tbody><tr id="tr">XXX<td>TD</td></tr></tbody></table>
+
+<script>
+document.body.offsetWidth;
+document.getElementById("tr").firstChild.data = '';
+</script>
+
+</body>
+</html>

layout/reftests/table-anonymous-boxes/3x3-cols-ref.html

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <body style="font-family: monospace">
-    <table cellpadding="0" cellspacing="0">
+    <table cellpadding="0" cellspacing="0" style="margin: 0; padding: 0; border: none">
       <colgroup><col style="background: yellow"><col style="background: cyan"><col style="background: lime"></colgroup>
       <tr>
         <td>Row 1, Col 1</td>

layout/reftests/table-anonymous-boxes/3x3-ref.html

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <body style="font-family: monospace">
-    <table cellpadding="0" cellspacing="0">
+    <table cellpadding="0" cellspacing="0" style="margin: 0; padding: 0; border: none">
       <tr>
         <td>Row 1, Col 1</td>
         <td>Row 1, Col 2</td>

layout/reftests/table-anonymous-boxes/dynamic-removal-14.html

@@ -3,7 +3,9 @@
   <head>
     <script>
       function doTest() {
-        document.normalize();
+        try {
+          document.normalize();
+        } catch(e) {}
         var n = document.getElementById("t").nextSibling;
         n.parentNode.removeChild(n);
         document.documentElement.className = "";

layout/reftests/table-anonymous-boxes/infer-cells-1.html

@@ -4,9 +4,10 @@
     <!-- The test in the first row might not be correct, depending on spec
          clarifications -->
     <span style="display: table-row"> 
-      <span>Row 1, Col 1</span>
-      <span>Row 1, Col 2</span>
-      <span>Row 1, Col 3</span>
+      <span>Row 1,</span>
+      <span>Col 1Row 1,</span>
+      <span>Col 2Row 1,</span>
+      <span>Col 3</span>
     </span>
     <span style="display: table-row"> 
       <span style="display: block">Row 22, Col 1Row 22, Col 2Row 22, Col 3</span>

layout/reftests/table-anonymous-boxes/reftest.list

@@ -4,12 +4,12 @@
 fails == 156888-1.html 156888-1-ref.html # bug 484825
 == 156888-2.html 156888-2-ref.html
 == 162063-1.xhtml about:blank
-== 203923-1.html white-space-1-ref.html
-== 203923-2.html white-space-1-ref.html
+== 203923-1.html white-space-ref.html
+== 203923-2.html white-space-ref.html
 == 208305-1.html 208305-1-ref.html
-== 208305-2.html white-space-1-ref.html
-== 208305-3.html white-space-1-ref.html
-== 208305-4.html white-space-1-ref.html
+== 208305-2.html white-space-ref.html
+== 208305-3.html white-space-ref.html
+== 208305-4.html white-space-ref.html
 == 277995-1.html 277995-1-ref.html
 == 293576-1.html 293576-1-ref.html
 == 302113-1.html 302113-1-ref.html
@@ -22,6 +22,9 @@ fails == 156888-1.html 156888-1-ref.html # bug 484825
 == 363326-1.html 363326-1-ref.html
 == 368932-1.html 368932-1-ref.html
 == 371054-1.html 371054-1-ref.html
+== 372641-1a.xhtml 372641-1-ref.xhtml
+== 372641-1b.xhtml 372641-1-ref.xhtml
+== 372641-1c.xhtml 372641-1-ref.xhtml
 == 372649-1.html 372649-1-ref.html
 == 373379-1.html 373379-1-ref.html
 == 394402-1a.html 394402-1-ref.html
@@ -39,6 +42,7 @@ fails == 156888-1.html 156888-1-ref.html # bug 484825
 == infer-table-row-cell.html 3x3-ref.html # Or should it be?  Spec is unclear.
 == infer-table.html 3x3-ref.html
 != 3-tables-ref.html 3x3-ref.html
+== 3-tables-ref.html 3-blocks-ref.html
 == blocks-divide-tables-1.html 3-tables-ref.html
 == blocks-divide-tables-2.html 3-tables-ref.html
 == infer-cells-1.html 3-tables-ref.html
@@ -56,10 +60,10 @@ fails == 156888-1.html 156888-1-ref.html # bug 484825
 == dynamic-removal-6.html 3x3-ref.html
 == dynamic-removal-7.html 3x3-ref.html
 == dynamic-removal-8.html 3x3-ref.html
-== dynamic-removal-9.html white-space-1-ref.html
-== dynamic-removal-10.html white-space-1-ref.html
-== dynamic-removal-11.html white-space-1-ref.html
-== dynamic-removal-12.html white-space-1-ref.html
+== dynamic-removal-9.html white-space-ref.html
+== dynamic-removal-10.html white-space-ref.html
+== dynamic-removal-11.html white-space-ref.html
+== dynamic-removal-12.html white-space-ref.html
 == dynamic-removal-13.html 3x3-ref.html
 == dynamic-removal-14.html 3x3-ref.html
 == dynamic-insert-cell-1.html 3x3-ref.html
@@ -73,4 +77,30 @@ fails == 156888-1.html 156888-1-ref.html # bug 484825
 == dynamic-switch-inline-to-cell-3.html 3x3-ref.html
 == dynamic-switch-inline-to-cell-4.html 3x3-ref.html
 == dynamic-switch-inline-to-cell-5.html 3x3-ref.html
-== white-space-1.html white-space-1-ref.html
+== white-space-1.html 3-tables-ref.html
+== white-space-2.html 3x3-ref.html
+== white-space-3.html 3x3-ref.html
+== white-space-4.html 3x3-ref.html
+== white-space-5.html 3x3-ref.html
+== white-space-6.html 3x3-ref.html
+== white-space-7.html white-space-ref.html
+== white-space-8.html white-space-ref.html
+== white-space-9.html white-space-ref.html
+== white-space-10.html white-space-ref.html
+== white-space-11.html white-space-ref.html
+== white-space-12.html white-space-ref.html
+== white-space-13.html white-space-ref.html
+== white-space-14.html white-space-ref.html
+== white-space-15.html white-space-ref.html
+== white-space-16.html white-space-ref.html
+== white-space-17.html white-space-ref.html
+== white-space-18.html white-space-ref.html
+== white-space-19.html white-space-ref.html
+== white-space-20.html white-space-ref.html
+== white-space-21.html white-space-ref.html
+== white-space-22.html white-space-ref.html
+== white-space-23.html white-space-ref.html
+== white-space-24.html white-space-ref.html
+== white-space-25.html white-space-ref.html
+== white-space-26.html white-space-ref.html
+== white-space-pre-1.html white-space-pre-ref.html

layout/reftests/table-anonymous-boxes/white-space-1.html

@@ -1,11 +1,20 @@
-<!DOCTYPE HTML>
-<html>
-  <body>
-    <span>
-      <span>a</span>
-      <span style="display: table-cell">b</span>
-      <span style="display: table-cell">c</span>
-      <span>d</span>
-    </span>
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var n = document.getElementById("t").nextSibling;
+        n.data = "Row 22, Col 1Row 22, Col 2Row 22, Col 3";
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body style="font-family: monospace" onload="doTest()">
+    <span style="display: table-cell">Row 1, Col 1</span>
+    <span style="display: table-cell">Row 1, Col 2</span>
+    <span style="display: table-cell" id="t">Row 1, Col 3</span>
+    <span style="display: table-cell">Row 333, Col 1</span>
+    <span style="display: table-cell">Row 333, Col 2</span>
+    <span style="display: table-cell">Row 333, Col 3</span>
   </body>
 </html>

layout/reftests/table-anonymous-boxes/white-space-10.html

@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var t = document.getElementById("t1");
+        t.parentNode.removeChild(t);
+        t = document.getElementById("t2");
+        t.parentNode.removeChild(t);
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body onload="doTest()">
+    <span>
+      <span>a</span><span style="display: table-cell" id="t1">e</span>
+      <span style="display: table-cell" id="t2">f</span><span>bc d</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-11.html

@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var t = document.getElementById("t1");
+        t.parentNode.removeChild(t);
+        t = document.getElementById("t2");
+        t.parentNode.removeChild(t);
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body onload="doTest()">
+    <span>
+      <span>a</span><span style="display: table-cell" id="t2">e</span>
+      <span style="display: table-cell" id="t1">f</span><span>bc d</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-12.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <span>
+      a
+      <span style="display: table-cell">b</span><span style="display: table-cell">c</span>
+      d
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-13.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <span>
+      a
+      <span style="display: table-cell">b</span>
+      <span style="display: table-cell">c</span>
+      d
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-14.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:after { content: "d" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      a
+      <span style="display: table-cell">b</span><span style="display: table-cell">c</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-15.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:after { content: "d" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      a
+      <span style="display: table-cell">b</span>
+      <span style="display: table-cell">c</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-16.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:after { content: "d" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      a
+      <span style="display: table-cell">b</span><script>document.body.offsetWidth</script><span style="display: table-cell">c</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-17.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:after { content: "d" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      a
+      <span style="display: table-cell">b</span>
+      <script>document.body.offsetWidth</script>
+      <span style="display: table-cell">c</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-18.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:before { content: "a" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      <span style="display: table-cell">b</span><span style="display: table-cell">c</span>
+      d
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-19.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:before { content: "a" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      <span style="display: table-cell">b</span>
+      <span style="display: table-cell">c</span>
+      d
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-2.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        try {
+          document.normalize();
+        } catch (e) {}
+        var n = document.getElementById("t").nextSibling;
+        n.data = " ";
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body style="font-family: monospace" onload="doTest()">
+    <span style="display: table-row">
+      <span style="display: table-cell">Row 1, Col 1</span>
+      <span style="display: table-cell">Row 1, Col 2</span>
+      <span style="display: table-cell">Row 1, Col 3</span>
+    </span>
+    <span style="display: table-row" id="t">
+      <span style="display: table-cell">Row 22, Col 1</span>
+      <span style="display: table-cell">Row 22, Col 2</span>
+      <span style="display: table-cell">Row 22, Col 3</span>
+    </span>This is a test<span style="display: table-row">
+      <span style="display: table-cell">Row 333, Col 1</span>
+      <span style="display: table-cell">Row 333, Col 2</span>
+      <span style="display: table-cell">Row 333, Col 3</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-20.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:before { content: "a" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      <span style="display: table-cell">b</span><script>document.body.offsetWidth</script><span style="display: table-cell">c</span>
+      d
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-21.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:before { content: "a" }
+    </style>
+  </head>  
+  <body>
+    <span id="t">
+      <span style="display: table-cell">b</span>
+      <script>document.body.offsetWidth</script>
+      <span style="display: table-cell">c</span>
+      d
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-22.html

@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <span style="display:table-row; white-space: pre"><span style="display: table-cell">a</span> bc <span style="display: table-cell">d</span></span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-23.html

@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <span style="display:table-row; white-space: pre"><span style="display: table-cell">a</span> <span>bc</span> <span style="display: table-cell">d</span></span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-24.html

@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <span style="display:table-row; white-space: pre"><span style="display: table-cell">a</span> <script>document.body.offsetWidth</script>bc<script>document.body.offsetWidth</script> <span style="display: table-cell">d</span></span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-25.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var t = document.getElementById("t");
+        var parent = t.parentNode;
+        parent.insertBefore(document.createTextNode(" "), t);
+        parent.insertBefore(document.createTextNode("bc"), t);
+        parent.insertBefore(document.createTextNode(" "), t);
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body onload="doTest()">
+    <span style="display:table-row; white-space: pre"><span style="display: table-cell">a</span><span id="t" style="display: table-cell">d</span></span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-26.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #t:after { display: table-cell; content: "d"; }
+    </style>
+  </head>
+  <body>
+    <span id="t">
+      a<script>document.body.offsetWidth;</script> <span style="display: table-cell; white-space: pre">bc </span></span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-3.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        try {
+          document.normalize();
+        } catch (e) {}
+        var n = document.getElementById("t").nextSibling;
+        n.data = " ";
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body style="font-family: monospace" onload="doTest()">
+    <span style="display: table-row-group">
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 1, Col 1</span>
+        <span style="display: table-cell">Row 1, Col 2</span>
+        <span style="display: table-cell">Row 1, Col 3</span>
+      </span>
+      <span style="display: table-row">
+        <span style="display: table-cell" id="t">Row 22, Col 1</span>This is a test<span style="display: table-cell">Row 22, Col 2</span>
+        <span style="display: table-cell">Row 22, Col 3</span>
+      </span>
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 333, Col 1</span>
+        <span style="display: table-cell">Row 333, Col 2</span>
+        <span style="display: table-cell">Row 333, Col 3</span>
+      </span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-4.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var n = document.getElementById("t").nextSibling;
+        n.data = "Row 22, Col 1";
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body style="font-family: monospace" onload="doTest()">
+    <span style="display: table-row-group">
+      <span style="display: table-row" id="t">
+        <span style="display: table-cell">Row 1, Col 1</span>
+        <span style="display: table-cell">Row 1, Col 2</span>
+        <span style="display: table-cell">Row 1, Col 3</span>
+      </span>
+      <span style="display: table-cell">Row 22, Col 2</span>
+      <span style="display: table-cell">Row 22, Col 3</span>
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 333, Col 1</span>
+        <span style="display: table-cell">Row 333, Col 2</span>
+        <span style="display: table-cell">Row 333, Col 3</span>
+      </span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-5.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var n = document.getElementById("t").nextSibling;
+        n.data = "Row 22, Col 2";
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body style="font-family: monospace" onload="doTest()">
+    <span style="display: table-row-group">
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 1, Col 1</span>
+        <span style="display: table-cell">Row 1, Col 2</span>
+        <span style="display: table-cell">Row 1, Col 3</span>
+      </span>
+      <span style="display: table-cell" id="t">Row 22, Col 1</span>
+      <span style="display: table-cell">Row 22, Col 3</span>
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 333, Col 1</span>
+        <span style="display: table-cell">Row 333, Col 2</span>
+        <span style="display: table-cell">Row 333, Col 3</span>
+      </span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-6.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var n = document.getElementById("t").nextSibling;
+        n.data = "Row 22, Col 3";
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body style="font-family: monospace" onload="doTest()">
+    <span style="display: table-row-group">
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 1, Col 1</span>
+        <span style="display: table-cell">Row 1, Col 2</span>
+        <span style="display: table-cell">Row 1, Col 3</span>
+      </span>
+      <span style="display: table-cell">Row 22, Col 1</span>
+      <span style="display: table-cell" id="t">Row 22, Col 2</span>
+      <span style="display: table-row">
+        <span style="display: table-cell">Row 333, Col 1</span>
+        <span style="display: table-cell">Row 333, Col 2</span>
+        <span style="display: table-cell">Row 333, Col 3</span>
+      </span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-7.html

@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+  <body>
+    <span>
+      <span>a</span>
+      <span style="display: table-cell">b</span>
+      <span style="display: table-cell">c</span>
+      <span>d</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-8.html

@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var t = document.getElementById("t");
+        t.parentNode.removeChild(t);
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body onload="doTest()">
+    <span>
+      <span>a</span><span style="display: table-cell" id="t">e</span>
+      <span style="display: table-cell">b</span><span>c d</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-9.html

@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html class="reftest-wait">
+  <head>
+    <script>
+      function doTest() {
+        var t = document.getElementById("t");
+        t.parentNode.removeChild(t);
+        document.documentElement.className = "";
+      }
+    </script>
+  </head>
+  <body onload="doTest()">
+    <span>
+      <span>a b</span><span style="display: table-cell">c</span>
+      <span style="display: table-cell" id="t">e</span><span>d</span>
+    </span>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-pre-1.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      #x:after { content: " cd"; display: table-cell; }
+    </style>
+    <script>
+      function doTest() {
+        var f = document.getElementById("f");
+        f.parentNode.removeChild(f);
+      }
+    </script>
+  </head>
+  <body onload="doTest()">
+    <div style="font-family: monospace; width: 10em; white-space: pre-wrap"><span id="f" style="float: left; width: 80%; height: 0.5em"></span><span id="x">a <script>document.body.offsetWidth; dump('aa');</script> <span style="display: table-cell">b</span></span></div>
+  </body>
+</html>

layout/reftests/table-anonymous-boxes/white-space-pre-ref.html

@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <div style="font-family: monospace; white-space: pre-wrap">a  b cd</div>
+  </body>
+</html>

layout/tables/nsTableColFrame.h

@@ -90,12 +90,6 @@ public:
                               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
    *

layout/tables/nsTableColGroupFrame.h

@@ -147,12 +147,6 @@ public:
      nsTableFrame::ReflowColGroups */
   virtual PRBool IsContainingBlock() const;
 
-  virtual PRBool IsFrameOfType(PRUint32 aFlags) const
-  {
-    return nsHTMLContainerFrame::IsFrameOfType(aFlags &
-      ~nsIFrame::eExcludesIgnorableWhitespace);
-  }
-
   /**
    * Get the "type" of the frame
    *

layout/tables/nsTableFrame.h

@@ -374,12 +374,6 @@ public:
                                         nsIFrame**      aProviderFrame,
                                         PRBool*         aIsChild);
 
-  virtual PRBool IsFrameOfType(PRUint32 aFlags) const
-  {
-    return nsHTMLContainerFrame::IsFrameOfType(aFlags &
-      ~nsIFrame::eExcludesIgnorableWhitespace);
-  }
-
   /**
    * Get the "type" of the frame
    *

layout/tables/nsTableOuterFrame.h

@@ -100,12 +100,6 @@ public:
 
   virtual void Destroy();
   
-  virtual PRBool IsFrameOfType(PRUint32 aFlags) const
-  {
-    return nsHTMLContainerFrame::IsFrameOfType(aFlags &
-      ~nsIFrame::eExcludesIgnorableWhitespace);
-  }
-
   virtual PRBool IsContainingBlock() const;
 
   NS_IMETHOD SetInitialChildList(nsIAtom*        aListName,

layout/tables/nsTableRowFrame.h

@@ -124,12 +124,6 @@ public:
 
   void DidResize();
 
-  virtual PRBool IsFrameOfType(PRUint32 aFlags) const
-  {
-    return nsHTMLContainerFrame::IsFrameOfType(aFlags &
-      ~nsIFrame::eExcludesIgnorableWhitespace);
-  }
-
   /**
    * Get the "type" of the frame
    *

layout/tables/nsTableRowGroupFrame.h

@@ -142,12 +142,6 @@ public:
                     const nsHTMLReflowState& aReflowState,
                     nsReflowStatus&          aStatus);
 
-  virtual PRBool IsFrameOfType(PRUint32 aFlags) const
-  {
-    return nsHTMLContainerFrame::IsFrameOfType(aFlags &
-      ~nsIFrame::eExcludesIgnorableWhitespace);
-  }
-
   /**
    * Get the "type" of the frame
    *