[New Multicolumn] Actual support for layout of column-span:all.

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 39 matching lines @@
 #include "core/html/HTMLTableElement.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Page.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/rendering/FlowThreadController.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/RenderCounter.h"
 #include "core/rendering/RenderDeprecatedFlexibleBox.h"
 #include "core/rendering/RenderFlexibleBox.h"
-#include "core/rendering/RenderFlowThread.h"
 #include "core/rendering/RenderGeometryMap.h"
 #include "core/rendering/RenderGrid.h"
 #include "core/rendering/RenderImage.h"
 #include "core/rendering/RenderImageResourceStyleImage.h"
 #include "core/rendering/RenderInline.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderListItem.h"
+#include "core/rendering/RenderMultiColumnFlowThread.h"
 #include "core/rendering/RenderObjectInlines.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderScrollbarPart.h"
 #include "core/rendering/RenderTableCaption.h"
 #include "core/rendering/RenderTableCell.h"
 #include "core/rendering/RenderTableCol.h"
 #include "core/rendering/RenderTableRow.h"
 #include "core/rendering/RenderTheme.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/CompositedLayerMapping.h"
@@ skipping 240 matching lines @@
         return !isTable();
     else if (newChild->isTableSection())
         return !isTable();
     else if (newChild->isTableRow())
         return !isTableSection();
     else if (newChild->isTableCell())
         return !isTableRow();
     return false;
 }
 
+bool RenderObject::isValidColumnSpanAll() const
+{
+    ASSERT(style()->columnSpan() == ColumnSpanAll);
+    RenderFlowThread* flowThread = flowThreadContainingBlock();
+    return flowThread && flowThread->isColumnSpanner(this);
+}
+
 void RenderObject::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
     ASSERT(isAllowedToModifyRenderTreeStructure(document()));
 
     RenderObjectChildList* children = virtualChildren();
     ASSERT(children);
     if (!children)
         return;
 
     if (requiresAnonymousTableWrappers(newChild)) {
@@ skipping 289 matching lines @@
     // See if we have the thread cached because we're in the middle of layout.
     RenderFlowThread* flowThread = view()->flowThreadController()->currentRenderFlowThread();
     if (flowThread)
         return flowThread;
 
     // Not in the middle of layout so have to find the thread the slow way.
     RenderObject* curr = const_cast<RenderObject*>(this);
     while (curr) {
         if (curr->isRenderFlowThread())
             return toRenderFlowThread(curr);
-        curr = curr->containingBlock();
+        switch (curr->style()->position()) {
+        case FixedPosition:
+            curr = curr->containerForFixedPosition();
+            break;
+        case AbsolutePosition:
+            curr = curr->containerForAbsolutePosition();
+            break;
+        default:
+            curr = curr->parentBlock();
+            break;
+        }
     }
     return 0;
 }
 
 bool RenderObject::skipInvalidationWhenLaidOutChildren() const
 {
     if (!neededLayoutBecauseOfChildren())
         return false;
 
     // SVG renderers need to be invalidated when their children are laid out.
@@ skipping 146 matching lines @@
     RenderObject* ancestor = parent();
     for (; ancestor && !ancestor->canContainFixedPositionObjects(); ancestor = ancestor->parent()) {
         if (paintInvalidationContainerSkipped && ancestor == paintInvalidationContainer)
             *paintInvalidationContainerSkipped = true;
     }
 
     ASSERT(!ancestor || !ancestor->isAnonymousBlock());
     return toRenderBlock(ancestor);
 }
 
-RenderBlock* RenderObject::containingBlock() const
+RenderBlock* RenderObject::containerForAbsolutePosition() const
 {
     RenderObject* o = parent();
-    if (!o && isRenderScrollbarPart())
-        o = toRenderScrollbarPart(this)->rendererOwningScrollbar();
-    if (!isText() && m_style->position() == FixedPosition) {
-        return containerForFixedPosition();
-    } else if (!isText() && m_style->position() == AbsolutePosition) {
-        while (o) {
-            // For relpositioned inlines, we return the nearest non-anonymous enclosing block. We don't try
-            // to return the inline itself.  This allows us to avoid having a positioned objects
-            // list in all RenderInlines and lets us return a strongly-typed RenderBlock* result
-            // from this method.  The container() method can actually be used to obtain the
-            // inline directly.
-            if (o->style()->position() != StaticPosition && (!o->isInline() || o->isReplaced()))
-                break;
+    while (o) {
+        // For relpositioned inlines, we return the nearest non-anonymous enclosing block. We don't try
+        // to return the inline itself.  This allows us to avoid having a positioned objects
+        // list in all RenderInlines and lets us return a strongly-typed RenderBlock* result
+        // from this method.  The container() method can actually be used to obtain the
+        // inline directly.
+        if (o->style()->position() != StaticPosition && (!o->isInline() || o->isReplaced()))
+            break;
 
-            if (o->canContainFixedPositionObjects())
-                break;
+        if (o->canContainFixedPositionObjects())
+            break;
 
-            if (o->style()->hasInFlowPosition() && o->isInline() && !o->isReplaced()) {
-                o = o->containingBlock();
-                break;
-            }
-
-            o = o->parent();
+        if (o->style()->hasInFlowPosition() && o->isInline() && !o->isReplaced()) {
+            o = o->parentBlock();
+            break;
         }
 
-        if (o && !o->isRenderBlock())
-            o = o->containingBlock();
+        o = o->parent();
+    }
 
-        while (o && o->isAnonymousBlock())
-            o = o->containingBlock();
-    } else {
-        while (o && ((o->isInline() && !o->isReplaced()) || !o->isRenderBlock()))
-            o = o->parent();
-    }
+    if (o && !o->isRenderBlock())
+        o = o->parentBlock();
+
+    while (o && o->isAnonymousBlock())
+        o = o->parentBlock();
+
+    return toRenderBlock(o);
+}
+
+RenderBlock* RenderObject::parentBlock() const
+{
+    RenderObject* o = parent();
+    while (o && ((o->isInline() && !o->isReplaced()) || !o->isRenderBlock()))
+        o = o->parent();
 
     if (!o || !o->isRenderBlock())
         return 0; // This can still happen in case of an orphaned tree
 
     return toRenderBlock(o);
 }
 
+RenderBlock* RenderObject::containingBlock() const
+{
+    if (!parent() && isRenderScrollbarPart()) {
+        RenderObject* o = toRenderScrollbarPart(this)->rendererOwningScrollbar();
+        if (o && !o->isRenderBlock())
+            o = o->parentBlock();
+        return toRenderBlock(o);
+    }
+    if (!isText()) {
+        if (m_style->position() == FixedPosition)
+            return containerForFixedPosition();
+        if (m_style->position() == AbsolutePosition)
+            return containerForAbsolutePosition();
+    }
+    if (isColumnSpanAll())
+        return toRenderMultiColumnFlowThread(flowThreadContainingBlock())->multiColumnBlockFlow();
+    return parentBlock();
+}
+
 bool RenderObject::canRenderBorderImage() const
 {
     if (!style()->hasBorder())
         return false;
 
     StyleImage* borderImage = style()->borderImage().image();
     return borderImage && borderImage->canRender(*this, style()->effectiveZoom()) && borderImage->isLoaded();
 }
 
 bool RenderObject::mustInvalidateFillLayersPaintOnWidthChange(const FillLayer& layer) const
@@ skipping 1529 matching lines @@
     if (slowFirstChild() || hasLayer()) {
         if (!layer)
             layer = parent()->enclosingLayer();
         removeLayers(layer);
     }
 
     if (isOutOfFlowPositioned() && parent()->childrenInline())
         parent()->dirtyLinesFromChangedChild(this);
 
     removeFromRenderFlowThread();
+    RELEASE_ASSERT(!isColumnSpanAll()); // Former spanners should have been removed from the flow thread map by now.
 
     // Update cached boundaries in SVG renderers if a child is removed.
     if (parent()->isSVG())
         parent()->setNeedsBoundariesUpdate();
 }
 
 void RenderObject::removeFromRenderFlowThread()
 {
     if (flowThreadState() == NotInsideFlowThread)
         return;
 
     // Sometimes we remove the element from the flow, but it's not destroyed at that time.
     // It's only until later when we actually destroy it and remove all the children from it.
     // Currently, that happens for firstLetter elements and list markers.
     // Pass in the flow thread so that we don't have to look it up for all the children.
     removeFromRenderFlowThreadRecursive(flowThreadContainingBlock());
 }
 
 void RenderObject::removeFromRenderFlowThreadRecursive(RenderFlowThread* renderFlowThread)
 {
     if (const RenderObjectChildList* children = virtualChildren()) {
         for (RenderObject* child = children->firstChild(); child; child = child->nextSibling())
             child->removeFromRenderFlowThreadRecursive(renderFlowThread);
     }
+
+    if (renderFlowThread && renderFlowThread != this)
+        renderFlowThread->flowThreadDescendantWillBeRemoved(this);
     setFlowThreadState(NotInsideFlowThread);
 }
 
 void RenderObject::destroyAndCleanupAnonymousWrappers()
 {
     // If the tree is destroyed, there is no need for a clean-up phase.
     if (documentBeingDestroyed()) {
         destroy();
         return;
     }
@@ skipping 717 matching lines @@
 {
     if (object1) {
         const blink::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif