An object may become a column spanner or cease to be one even if column-span doesn't change.

Source/core/layout/LayoutMultiColumnFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 343 matching lines @@
     m_inBalancingPass = needsRelayout;
     return needsRelayout;
 }
 
 void LayoutMultiColumnFlowThread::columnRuleStyleDidChange()
 {
     for (LayoutMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
         columnSet->setShouldDoFullPaintInvalidation(PaintInvalidationStyleChange);
 }
 
+bool LayoutMultiColumnFlowThread::removeSpannerPlaceholderIfNoLongerValid(LayoutBox* spannerObjectInFlowThread)
+{
+    ASSERT(spannerObjectInFlowThread->spannerPlaceholder());
+    if (descendantIsValidColumnSpanner(spannerObjectInFlowThread))
+        return false; // Still a valid spanner.
+
+    // No longer a valid spanner. Get rid of the placeholder.
+    destroySpannerPlaceholder(spannerObjectInFlowThread->spannerPlaceholder());
+    ASSERT(!spannerObjectInFlowThread->spannerPlaceholder());
+
+    // We may have a new containing block, since we're no longer a spanner. Mark it for relayout.
+    spannerObjectInFlowThread->containingBlock()->setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::ColumnsChanged);
+
+    // Now generate a column set for this ex-spanner, if needed and none is there for us already.
+    flowThreadDescendantWasInserted(spannerObjectInFlowThread);
+
+    return true;
+}
+
 void LayoutMultiColumnFlowThread::calculateColumnCountAndWidth(LayoutUnit& width, unsigned& count) const
 {
     LayoutBlock* columnBlock = multiColumnBlockFlow();
     const ComputedStyle* columnStyle = columnBlock->style();
     LayoutUnit availableWidth = columnBlock->contentLogicalWidth();
     LayoutUnit columnGap = columnBlock->columnGap();
     LayoutUnit computedColumnWidth = max<LayoutUnit>(1, LayoutUnit(columnStyle->columnWidth()));
     unsigned computedColumnCount = max<int>(1, columnStyle->columnCount());
 
     ASSERT(!columnStyle->hasAutoColumnCount() || !columnStyle->hasAutoColumnWidth());
@@ skipping 77 matching lines @@
             nextColumnBox->destroy();
             previousColumnBox->setNeedsLayout(LayoutInvalidationReason::ColumnsChanged);
             invalidateColumnSets();
         }
     }
     placeholder->destroy();
 }
 
 bool LayoutMultiColumnFlowThread::descendantIsValidColumnSpanner(LayoutObject* descendant) const
 {
+    // This method needs to behave correctly in the following situations:
+    // - When the descendant doesn't have a spanner placeholder but should have one (return true)
+    // - When the descendant doesn't have a spanner placeholder and still should not have one (return false)
+    // - When the descendant has a spanner placeholder but should no longer have one (return false)
+    // - When the descendant has a spanner placeholder and should still have one (return true)
+
     // We assume that we're inside the flow thread. This function is not to be called otherwise.
     ASSERT(descendant->isDescendantOf(this));
 
-    // We're evaluating if the descendant should be turned into a proper spanner. It shouldn't
-    // already be one.
-    ASSERT(!descendant->spannerPlaceholder());
-
     // The spec says that column-span only applies to in-flow block-level elements.
     if (descendant->style()->columnSpan() != ColumnSpanAll || !descendant->isBox() || descendant->isInline() || descendant->isFloatingOrOutOfFlowPositioned())
         return false;
 
     if (!descendant->containingBlock()->isLayoutBlockFlow()) {
         // Needs to be in a block-flow container, and not e.g. a table.
         return false;
     }
 
     // This looks like a spanner, but if we're inside something unbreakable, it's not to be treated as one.
-    for (LayoutBlock* ancestor = descendant->containingBlock(); ancestor; ancestor = ancestor->containingBlock()) {
+    for (LayoutBox* ancestor = toLayoutBox(descendant)->parentBox(); ancestor; ancestor = ancestor->containingBlock()) {
         if (ancestor->isLayoutFlowThread()) {
             ASSERT(ancestor == this);
             return true;
         }
         if (ancestor->spannerPlaceholder()) {
             // FIXME: do we want to support nested spanners in a different way? The outer spanner
             // has already broken out from the columns to become sized by the multicol container,
             // which may be good enough for the inner spanner. But margins, borders, padding and
             // explicit widths on the outer spanner, or on any children between the outer and inner
             // spanner, will affect the width of the inner spanner this way, which might be
@@ skipping 216 matching lines @@
 void LayoutMultiColumnFlowThread::flowThreadDescendantStyleDidChange(LayoutObject* descendant, StyleDifference diff, const ComputedStyle& oldStyle)
 {
     // If an out-of-flow descendant goes in-flow, we may have to insert a column set.
     if (descendant->isText()) {
         // Text nodes inherit all properties from the parent node (including non-inheritable
         // ones). We don't care what its 'position' is. In fact, we _must_ ignore it, since the
         // parent may be the multicol container, and having that accidentally leaked into children
         // of the multicol is bad.
         return;
     }
-    if (oldStyle.hasOutOfFlowPosition() && !styleRef().hasOutOfFlowPosition())
+    if (styleRef().hasOutOfFlowPosition())
+        return;
+
+    // We're not out of flow.
+    if (oldStyle.hasOutOfFlowPosition()) {
+        // ... but we used to be out of flow. So we might need to insert a column set (or
+        // spanner placeholder, in case this descendant is now a valid column spanner).
         flowThreadDescendantWasInserted(descendant);
+        return;
+    }
+    if (descendantIsValidColumnSpanner(descendant)) {
+        // We went from being regular column content to becoming a spanner.
+        ASSERT(!toLayoutBox(descendant)->spannerPlaceholder());
+
+        // First remove this as regular column content. Note that this will walk the entire subtree
+        // of |descendant|. There might be spanners there (which won't be spanners anymore, since
+        // we're not allowed to nest spanners), whose placeholders must die.
+        flowThreadDescendantWillBeRemoved(descendant);
+
+        createAndInsertSpannerPlaceholder(toLayoutBox(descendant), nextInPreOrderAfterChildrenSkippingOutOfFlow(this, descendant));
+    }
 }
 
 void LayoutMultiColumnFlowThread::computePreferredLogicalWidths()
 {
     LayoutFlowThread::computePreferredLogicalWidths();
 
     // The min/max intrinsic widths calculated really tell how much space elements need when
     // laid out inside the columns. In order to eventually end up with the desired column width,
     // we need to convert them to values pertaining to the multicol container.
     const LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
@@ skipping 77 matching lines @@
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }