Move code for locating the containing flow thread out of LayoutObject.

Source/core/layout/LayoutFlowThread.cpp

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. 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.
@@ skipping 25 matching lines @@
 
 namespace blink {
 
 LayoutFlowThread::LayoutFlowThread()
     : LayoutBlockFlow(nullptr)
     , m_columnSetsInvalidated(false)
     , m_pageLogicalSizeChanged(false)
 {
 }
 
+LayoutFlowThread* LayoutFlowThread::locateFlowThreadContainingBlockOf(const LayoutObject& descendant)
+{
+    ASSERT(descendant.isInsideFlowThread());
+    LayoutObject* curr = const_cast<LayoutObject*>(&descendant);

[leviw_travelin_and_unemployed, 2015/08/11 17:51:07]

What fails in this function if you remove this const_cast?

[mstensho (USE GERRIT), 2015/08/11 19:09:18]

toLayoutFlowThread(), because the constness of input and output have to agree,
so we get the one that takes const returns const, and this methods returns (and
has to return) non-const.

Note that I'm not introducing any const cast with this patch, though. It used to
live in LayoutObject, but now I'm moving it here.

Other methods that do similar things (i.e. find something in the ancestry), such
as LayoutBlock* LayoutObject::containingBlock() const, shake off the constness
debuff by starting at their parent(). In this method we start at ourselves.

+    while (curr) {
+        if (curr->isSVG() && !curr->isSVGRoot())
+            return nullptr;
+        if (curr->isLayoutFlowThread())
+            return toLayoutFlowThread(curr);
+        LayoutObject* container = curr->container();
+        curr = curr->parent();
+        while (curr != container) {
+            if (curr->isLayoutFlowThread()) {
+                // The nearest ancestor flow thread isn't in our containing block chain. Then we
+                // aren't really part of any flow thread, and we should stop looking. This happens
+                // when there are out-of-flow objects or column spanners.
+                return nullptr;
+            }
+            curr = curr->parent();
+        }
+    }
+    return nullptr;
+}
+
 void LayoutFlowThread::removeColumnSetFromThread(LayoutMultiColumnSet* columnSet)
 {
     ASSERT(columnSet);
     m_multiColumnSetList.remove(columnSet);
     invalidateColumnSets();
     // Clear the interval tree right away, instead of leaving it around with dead objects. Not that
     // anyone _should_ try to access the interval tree when the column sets are marked as invalid,
     // but this is actually possible if other parts of the engine has bugs that cause us to not lay
     // out everything that was marked for layout, so that LayoutObject::assertLaidOut() (and a LOT
     // of other assertions) fails.
@@ skipping 126 matching lines @@
 
 void LayoutFlowThread::MultiColumnSetSearchAdapter::collectIfNeeded(const MultiColumnSetInterval& interval)
 {
     if (m_result)
         return;
     if (interval.low() <= m_offset && interval.high() > m_offset)
         m_result = interval.data();
 }
 
 } // namespace blink