[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();
+        curr = curr->container();

[Julien - ping for review, 2014/11/19 17:54:34]

Is this really correct? The main difference between containingBlock() and
container() is relative positioned inlines, which you shouldn't impact
multi-column.

[mstensho (USE GERRIT), 2014/11/21 15:39:24]

Now that containingBlock() may end up calling this method (because of spanner
awareness), I cannot call containingBlock() from here, or we'd get an infinite
recursion. :( This is why I went for the ugly stuff in RenderBox.cpp, that your
review comment had me revert.

So, what to do?

A: Introduce a parameter to containingBlock, that can be used to ignore special
treatment for spanners.
B: Split containingBlock() into pieces, so that we can easily jump to containing
blocks for abspos and fixedpos here.
C: duplicate as much as we need from containingBlock() here.

I went for B, because it seemed like the least ugly option (but admittedly the
big winner in terms of the number of changed code lines). I uploaded this as a
separate patch set. I kept using the beautiful variable 'o' for RenderObject*
here and there, mainly to minimize the diff, but maybe we could come up with
something longer?

     }
     return 0;
 }
 
 bool RenderObject::skipInvalidationWhenLaidOutChildren() const
 {
     if (!neededLayoutBecauseOfChildren())
         return false;
 
     // SVG renderers need to be invalidated when their children are laid out.
@@ skipping 179 matching lines @@
             }
 
             o = o->parent();
         }
 
         if (o && !o->isRenderBlock())
             o = o->containingBlock();
 
         while (o && o->isAnonymousBlock())
             o = o->containingBlock();
+    } else if (isColumnSpanAll()) {
+        o = toRenderMultiColumnFlowThread(flowThreadContainingBlock())->multiColumnBlockFlow();

[Julien - ping for review, 2014/11/19 17:54:34]

If you update containingBlock(), you should also update container().

[mstensho (USE GERRIT), 2014/11/21 15:39:24]

If I do that, I also have to deal with changed behavior in
RenderObject::markContainingBlocksForLayout(), which means that I'll have to
change how we get to the spanners during layout, since we won't necessarily
reach the parent RenderBlock of spanners anymore. By all means, this may turn
out to be a good and beautiful thing, but it will be a rather fundamental change
in this CL.

But I feel that I've already changed the code too much since last time you gave
feedback, so I won't do this until you've had a look at what I've done so far.
You might ask me to go back to doing a couple of ugly things with
RenderBox::containingBlockLogical{Width,Height}ForContent() instead. :)

Let me know if you still want me to patch container().

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

To follow up here: I tried this (make container() tell the truth, i.e. return
the multicol container as containing block for spanners). This has vast
consequences for the code, as expected, and kind of forces us to truly take
spanners out from the flow thread (pretty much similar to what we do for
absolutely positioned elements in general). I really liked the result, but I've
created new CLs for it (see top of comment). If you like them, we can drop this
CL.

     } else {
         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);
 }
@@ skipping 1564 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