[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();
+}

[Julien - ping for review, 2014/11/26 21:09:01]

A lot of this containing-block related change is orthogonal to adding
column-span: all support. Please split it into a preparatory change (or a
post-landing refactoring but it's more tricky as it assumes column-span: all
sticks) to reduce the size of this change.

I am happy to review those preparatory changes as it reduces the amount of time
I have to spend on this mega-patch :(

[mstensho (USE GERRIT), 2014/11/27 21:20:29]

Yeah, as long as you think this is a good change on its own, I can land it
separately, and then rebase this CL on top of it.

[Julien - ping for review, 2014/12/03 23:02:22]

Anything that shrinks this patch should be split out and landed separately.

[mstensho (USE GERRIT), 2014/12/10 13:48:19]

I found a way around making this big change. The current problem is that while
you work on locating your containing block, you have to walk your containing
block chain to locate your flow thread, just to figure out if you're a spanner.
This information is currently found in the spanner hash map in
RenderMultiColumnFlowThread. If the column-span:all renderer instead had a
pointer to its RenderMultiColumnSpannerSet placeholder, we could avoid involving
the flow thread here.

Since we have established that the real containing block of a spanner is the
multicol container, the spanner really isn't part of the flow thread, so calling
spanner->flowThreadContainingBlock() should by right skip the nearest ancestor
flow thread, since it's not really part of it.

+
 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 1553 matching lines @@
     // 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