*** DO NOT LAND *** Implement column-span:all without reparenting renderers. Work in progress.

Source/core/rendering/RenderMultiColumnFlowThread.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 338 matching lines @@
         columnSet->detachRegion();
     multiColumnBlockFlow()->resetMultiColumnFlowThread();
     RenderFlowThread::willBeRemovedFromTree();
 }
 
 bool RenderMultiColumnFlowThread::hasColumnSpanner(const RenderObject* renderer) const
 {
     return m_spannerMap.get(renderer);
 }
 
-LayoutUnit RenderMultiColumnFlowThread::spannerLogicalTopAdjustment(RenderBox* renderer, LayoutUnit logicalTop) const
+LayoutUnit RenderMultiColumnFlowThread::enterColumnSpanner(RenderBox* renderer, LayoutUnit logicalTop)
 {
-    ASSERT(m_spannerMap.get(renderer) == m_lastSetWorkedOn);
-    RenderMultiColumnSet* previousSet = m_lastSetWorkedOn->previousSiblingMultiColumnSet();
-    if (!previousSet || previousSet->isRenderMultiColumnSpannerSet() || !previousSet->pageLogicalHeight())
+    ASSERT(renderer->isDescendantOf(this));
+    RenderMultiColumnSpannerSet* spannerSet = m_spannerMap.get(renderer);
+    ASSERT(spannerSet);
+    RenderMultiColumnSet* previousSet = spannerSet->previousSiblingMultiColumnSet();
+    if (!previousSet) {
+        // The first set is entered at the beginning of flow thread layout. If the first set happens
+        // to be a spanner, we have nothing more to do here.
         return LayoutUnit();
+    }
 
     RenderBlock* cb = renderer->containingBlock();
     LayoutUnit logicalTopInFlowThread = cb->offsetFromLogicalTopOfFirstPage() + logicalTop;
-    LayoutUnit columnLogicalTopInFlowThread = previousSet->pageLogicalTopForOffset(logicalTopInFlowThread);
-    if (columnLogicalTopInFlowThread == logicalTopInFlowThread)
-        return LayoutUnit(); // Exactly at the top of a column. No need to adjust.
-    return columnLogicalTopInFlowThread + previousSet->pageLogicalHeight() - logicalTopInFlowThread;
-}
-
-void RenderMultiColumnFlowThread::enterColumnSpanner(RenderBox* renderer, LayoutUnit& logicalTop)
-{
-    ASSERT(m_spannerMap.get(renderer));
-    ASSERT(renderer->isDescendantOf(this));
-
-    if (m_spannerMap.get(renderer) == m_lastSetWorkedOn) {
-        // The first set is entered at the beginning of flow thread layout. If the first set happens
-        // to be a spanner, we have nothing more to do here.
-        ASSERT(!m_lastSetWorkedOn->previousSiblingMultiColumnSet());
-        return;
+    LayoutUnit adjustment;
+    if (!previousSet->isRenderMultiColumnSpannerSet() && previousSet->pageLogicalHeight()) {
+        // Pad flow thread offset to a column boundary, so that contents that's supposed to come
+        // after the spanner (or the spanner itself) don't bleed into the column preceding the
+        // spanner.
+        LayoutUnit columnLogicalTopInFlowThread = previousSet->pageLogicalTopForOffset(logicalTopInFlowThread);
+        if (columnLogicalTopInFlowThread != logicalTopInFlowThread) {
+            adjustment = columnLogicalTopInFlowThread + previousSet->pageLogicalHeight() - logicalTopInFlowThread;
+            logicalTopInFlowThread += adjustment;
+        }
     }
 
-    RenderMultiColumnSet* previousSet = m_lastSetWorkedOn;
-    m_lastSetWorkedOn = m_lastSetWorkedOn->nextSiblingMultiColumnSet();
-    ASSERT(m_lastSetWorkedOn);
-    ASSERT(m_lastSetWorkedOn->isRenderMultiColumnSpannerSet());
-    ASSERT(toRenderMultiColumnSpannerSet(m_lastSetWorkedOn)->renderer() == renderer);
-
-    logicalTop += spannerLogicalTopAdjustment(renderer, logicalTop);
-    RenderBlock* cb = renderer->containingBlock();
-    LayoutUnit logicalTopInFlowThread = cb->offsetFromLogicalTopOfFirstPage() + logicalTop;
     if (!previousSet->isRenderMultiColumnSpannerSet())
         previousSet->endFlow(logicalTopInFlowThread);
-    m_lastSetWorkedOn->beginFlow(logicalTopInFlowThread);
+    spannerSet->beginFlow(logicalTopInFlowThread);
+
+    m_lastSetWorkedOn = spannerSet;
+    return adjustment;
 }
 
 void RenderMultiColumnFlowThread::leaveColumnSpanner(RenderBox* renderer, LayoutUnit logicalBottom)
 {
+    ASSERT(m_lastSetWorkedOn == m_spannerMap.get(renderer));
+
     RenderBlock* cb = renderer->containingBlock();
     LayoutUnit logicalBottomInFlowThread = cb->offsetFromLogicalTopOfFirstPage() + logicalBottom;
     m_lastSetWorkedOn->endFlow(logicalBottomInFlowThread);
     RenderMultiColumnSet* nextSet = m_lastSetWorkedOn->nextSiblingMultiColumnSet();
-    if (nextSet && !nextSet->isRenderMultiColumnSpannerSet()) {
+    if (nextSet) {
         m_lastSetWorkedOn = nextSet;
-        if (m_lastSetWorkedOn)
+        if (!m_lastSetWorkedOn->isRenderMultiColumnSpannerSet())
             m_lastSetWorkedOn->beginFlow(logicalBottomInFlowThread);
     }
 }
 
 void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject* descendant)
 {
     ASSERT(!m_beingEvacuated);
     RenderObject* subtreeRoot = descendant;
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     for (; descendant; descendant = descendant->nextInPreOrder(subtreeRoot)) {
@@ skipping 75 matching lines @@
                     invalidateRegions();
                 }
             }
             m_spannerMap.remove(descendant);
             spanner->destroy();
         }
         // FIXME: do we care that we might end up with (harmless) empty sets here?
     }
 }
 
+void RenderMultiColumnFlowThread::flowThreadDescendantStyleDidChange(RenderObject* descendant)
+{
+    ASSERT(descendant->isDescendantOf(this));
+    if (RenderMultiColumnSpannerSet* spanner = m_spannerMap.get(descendant)) {
+        RefPtr<RenderStyle> newStyle = RenderStyle::clone(style());
+        spanner->updateMarginProperties(newStyle.get(), descendant);
+        setStyle(newStyle);
+    }
+}
+
 void RenderMultiColumnFlowThread::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
 {
     // We simply remain at our intrinsic height.
     computedValues.m_extent = logicalHeight;
     computedValues.m_position = logicalTop;
 }
 
 void RenderMultiColumnFlowThread::updateLogicalWidth()
 {
     LayoutUnit columnWidth;
@@ skipping 82 matching lines @@
 }
 
 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (RenderMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }