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

Source/core/layout/LayoutMultiColumnSpannerPlaceholder.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 
 namespace blink {
 
 static void copyMarginProperties(ComputedStyle& placeholderStyle, const ComputedStyle& spannerStyle)
@@ skipping 16 matching lines @@
     newSpanner->setStyle(newStyle);
     return newSpanner;
 }
 
 LayoutMultiColumnSpannerPlaceholder::LayoutMultiColumnSpannerPlaceholder(LayoutBox* layoutObjectInFlowThread)
     : LayoutBox(nullptr)
     , m_layoutObjectInFlowThread(layoutObjectInFlowThread)
 {
 }
 
+void LayoutMultiColumnSpannerPlaceholder::layoutObjectInFlowThreadStyleDidChange(const ComputedStyle* oldStyle)
+{
+    LayoutBox* objectInFlowThread = m_layoutObjectInFlowThread;
+    if (flowThread()->removeSpannerPlaceholderIfNoLongerValid(objectInFlowThread)) {
+        // No longer a valid spanner, due to style changes. |this| is now dead.
+        if (objectInFlowThread->style()->hasOutOfFlowPosition() && !oldStyle->hasOutOfFlowPosition()) {
+            // We went from being a spanner to being out-of-flow positioned. When an object becomes
+            // out-of-flow positioned, we need to lay out its parent, since that's where the
+            // now-out-of-flow object gets added to the right containing block for out-of-flow
+            // positioned objects. Since neither a spanner nor an out-of-flow object is guaranteed
+            // to have this parent in its containing block chain, we need to mark it here, or we
+            // risk that the object isn't laid out.
+            objectInFlowThread->parent()->setNeedsLayout(LayoutInvalidationReason::ColumnsChanged);
+        }
+        return;
+    }
+    updateMarginProperties();
+}
+
 void LayoutMultiColumnSpannerPlaceholder::updateMarginProperties()
 {
     RefPtr<ComputedStyle> newStyle = ComputedStyle::clone(styleRef());
     copyMarginProperties(*newStyle, m_layoutObjectInFlowThread->styleRef());
     setStyle(newStyle);
 }
 
 void LayoutMultiColumnSpannerPlaceholder::willBeRemovedFromTree()
 {
-    if (m_layoutObjectInFlowThread)
+    if (m_layoutObjectInFlowThread) {
+        LayoutBox* exSpanner = m_layoutObjectInFlowThread;
         m_layoutObjectInFlowThread->clearSpannerPlaceholder();
+        // Even if the placeholder is going away, the object in the flow thread might live on. Since
+        // it's not a spanner anymore, it needs to be relaid out.
+        exSpanner->setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::ColumnsChanged);
+    }
     LayoutBox::willBeRemovedFromTree();
 }
 
 bool LayoutMultiColumnSpannerPlaceholder::needsPreferredWidthsRecalculation() const
 {
     return m_layoutObjectInFlowThread->needsPreferredWidthsRecalculation();
 }
 
 LayoutUnit LayoutMultiColumnSpannerPlaceholder::minPreferredLogicalWidth() const
 {
@@ skipping 45 matching lines @@
     if (!m_layoutObjectInFlowThread->hasSelfPaintingLayer())
         m_layoutObjectInFlowThread->paint(paintInfo, paintOffset);
 }
 
 bool LayoutMultiColumnSpannerPlaceholder::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action)
 {
     return !m_layoutObjectInFlowThread->hasSelfPaintingLayer() && m_layoutObjectInFlowThread->nodeAtPoint(result, locationInContainer, accumulatedOffset, action);
 }
 
 }