[New Multicolumn] Add RenderMultiColumnFlowThread::findSetRendering().

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 55 matching lines @@
 
 RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const
 {
     for (RenderObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isRenderMultiColumnSet())
             return toRenderMultiColumnSet(sibling);
     }
     return 0;
 }
 
+static RenderObject* firstRendererInSet(RenderMultiColumnSet* multicolSet)
+{
+    RenderBox* sibling = multicolSet->previousSiblingMultiColumnBox();
+    if (!sibling)
+        return multicolSet->flowThread()->firstChild();
+    // Adjacent column content sets should not occur. We would have no way of figuring out what each
+    // of them contains then.
+    ASSERT(sibling->isRenderMultiColumnSpannerPlaceholder());

[Julien - ping for review, 2015/01/22 10:23:08]

Note that this ASSERT is already covered by the
toRenderMultiColumnSpannerPlaceholder, which does it in release too. In this
case, it's nice to be explicit.

[mstensho (USE GERRIT), 2015/01/22 10:39:57]

Yeah, since I want to explain that adjacent sets is verboten, I might as well
throw in this extra assert, I thought.

+    return toRenderMultiColumnSpannerPlaceholder(sibling)->rendererInFlowThread()->nextInPreOrderAfterChildren(multicolSet->flowThread());
+}
+
+static RenderObject* lastRendererInSet(RenderMultiColumnSet* multicolSet)
+{
+    RenderBox* sibling = multicolSet->nextSiblingMultiColumnBox();
+    if (!sibling)
+        return 0;

[Julien - ping for review, 2015/01/22 10:23:08]

Shouldn't this return multicolSet->flowThread()->lastChild() to match
firstRendererInSet? /me has a sense of deja-vu on this question but has to ask
again

[mstensho (USE GERRIT), 2015/01/22 10:39:57]

I could use *lastLeafChild()*. The only caller of this function doesn't really
care, though, so I thought it was just waste of time and binary code size. Then
you could say that it's not very nice behavior to return 0 here... That's why I
initially (in an earlier CL that got dropped) actually didn't have
firstRendererInSet() and lastRendererInSet(), but just had the code inside
findSetRendering(), to allow for tighter coupling, without writing mildly
"misbehaving" functions.

Let me know if I should change anything.

[Julien - ping for review, 2015/01/22 11:45:44]

Let's add a comment about this in the code to document that it's OK to do that.

[mstensho (USE GERRIT), 2015/01/22 11:53:39]

Done.

+    // Adjacent column content sets should not occur. We would have no way of figuring out what each
+    // of them contains then.
+    ASSERT(sibling->isRenderMultiColumnSpannerPlaceholder());
+    return toRenderMultiColumnSpannerPlaceholder(sibling)->rendererInFlowThread()->previousInPreOrder(multicolSet->flowThread());
+}
+
+RenderMultiColumnSet* RenderMultiColumnFlowThread::findSetRendering(RenderObject* renderer) const
+{
+    ASSERT(!containingColumnSpannerPlaceholder(renderer)); // should not be used for spanners or content inside them.
+    ASSERT(renderer != this && renderer->isDescendantOf(this));

[Julien - ping for review, 2015/01/22 10:23:08]

It's better to split && into different ASSERTs. The reason is that when it
fails, you don't know which part of the predicate failed.

[mstensho (USE GERRIT), 2015/01/22 10:39:57]

Indeed.
Done.

+    RenderMultiColumnSet* multicolSet = firstMultiColumnSet();
+    if (!multicolSet)
+        return 0;
+    if (!multicolSet->nextSiblingMultiColumnSet())
+        return multicolSet;
+
+    // This is potentially SLOW! But luckily very uncommon. You would have to dynamically insert a
+    // spanner into the middle of column contents to need this.
+    for (; multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
+        RenderObject* firstRenderer = firstRendererInSet(multicolSet);
+        RenderObject* lastRenderer = lastRendererInSet(multicolSet);
+        ASSERT(firstRenderer);
+
+        for (RenderObject* walker = firstRenderer; walker; walker = walker->nextInPreOrder(this)) {
+            if (walker == renderer)
+                return multicolSet;
+            if (walker == lastRenderer)
+                break;
+        }
+    }
+
+    return 0;
+}
+
 RenderMultiColumnSpannerPlaceholder* RenderMultiColumnFlowThread::containingColumnSpannerPlaceholder(const RenderObject* descendant) const
 {
     ASSERT(descendant->isDescendantOf(this));
 
     // Before we spend time on searching the ancestry, see if there's a quick way to determine
     // whether there might be any spanners at all.
     RenderBox* firstBox = firstMultiColumnBox();
     if (!firstBox || (firstBox == lastMultiColumnBox() && firstBox->isRenderMultiColumnSet()))
         return 0;
 
@@ skipping 410 matching lines @@
 }
 
 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (RenderMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }