Rename findSetLayoutObjects() to mapDescendantToColumnSet()

Source/core/layout/LayoutMultiColumnFlowThread.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 77 matching lines @@
 {
     LayoutBox* sibling = multicolSet->nextSiblingMultiColumnBox();
     if (!sibling)
         return 0; // By right we should return lastLeafChild() here, but the caller doesn't care, so just return 0.
     // Adjacent column content sets should not occur. We would have no way of figuring out what each
     // of them contains then.
     ASSERT(sibling->isLayoutMultiColumnSpannerPlaceholder());
     return toLayoutMultiColumnSpannerPlaceholder(sibling)->layoutObjectInFlowThread()->previousInPreOrder(multicolSet->flowThread());
 }
 
-LayoutMultiColumnSet* LayoutMultiColumnFlowThread::findSetLayoutObjects(LayoutObject* layoutObject) const
+LayoutMultiColumnSet* LayoutMultiColumnFlowThread::mapDescendantToColumnSet(LayoutObject* layoutObject) const
 {
     ASSERT(!containingColumnSpannerPlaceholder(layoutObject)); // should not be used for spanners or content inside them.
     ASSERT(layoutObject != this);
     ASSERT(layoutObject->isDescendantOf(this));
     LayoutMultiColumnSet* multicolSet = firstMultiColumnSet();
     if (!multicolSet)
         return 0;
     if (!multicolSet->nextSiblingMultiColumnSet())
         return multicolSet;
 
@@ skipping 400 matching lines @@
                         // which means that we simply insert a new spanner placeholder at the
                         // beginning.
                         insertBefore = firstMultiColumnBox();
                     } else if (LayoutMultiColumnSpannerPlaceholder* previousPlaceholder = containingColumnSpannerPlaceholder(previousLayoutObject)) {
                         // Before us is another spanner. We belong right after it then.
                         insertBefore = previousPlaceholder->nextSiblingMultiColumnBox();
                     } else {
                         // We're inside regular column content with both feet. Find out which column
                         // set this is. It needs to be split it into two sets, so that we can insert
                         // a new spanner placeholder between them.
-                        setToSplit = findSetLayoutObjects(previousLayoutObject);
-                        ASSERT(setToSplit == findSetLayoutObjects(objectAfterSubtree));
+                        setToSplit = mapDescendantToColumnSet(previousLayoutObject);
+                        ASSERT(setToSplit == mapDescendantToColumnSet(objectAfterSubtree));
                         setToSplit->setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::ColumnsChanged);
                         insertBefore = setToSplit->nextSiblingMultiColumnBox();
                         // We've found out which set that needs to be split. Now proceed to
                         // inserting the spanner placeholder, and then insert a second column set.
                     }
                 }
                 ASSERT(setToSplit || insertBefore);
             }
             createAndInsertSpannerPlaceholder(toLayoutBox(layoutObject), insertBefore);
             if (setToSplit)
@@ skipping 18 matching lines @@
         }
         if (objectAfterSubtree) {
             if (LayoutMultiColumnSpannerPlaceholder* placeholder = objectAfterSubtree->spannerPlaceholder()) {
                 // If inserted right before a spanner, we need to make sure that there's a set for us there.
                 LayoutBox* previous = placeholder->previousSiblingMultiColumnBox();
                 if (!previous || !previous->isLayoutMultiColumnSet())
                     createAndInsertMultiColumnSet(placeholder);
             } else {
                 // Otherwise, since |objectAfterSubtree| isn't a spanner, it has to mean that there's
                 // already a set for that content. We can use it for this layoutObject too.
-                ASSERT(findSetLayoutObjects(objectAfterSubtree));
-                ASSERT(findSetLayoutObjects(layoutObject) == findSetLayoutObjects(objectAfterSubtree));
+                ASSERT(mapDescendantToColumnSet(objectAfterSubtree));
+                ASSERT(mapDescendantToColumnSet(layoutObject) == mapDescendantToColumnSet(objectAfterSubtree));
             }
         } else {
             // Inserting at the end. Then we just need to make sure that there's a column set at the end.
             LayoutBox* lastColumnBox = lastMultiColumnBox();
             if (!lastColumnBox || !lastColumnBox->isLayoutMultiColumnSet())
                 createAndInsertMultiColumnSet();
         }
     }
 }
 
@@ skipping 45 matching lines @@
             return; // Preceded by column content. Set still needed.
     }
     LayoutMultiColumnSpannerPlaceholder* adjacentNextSpannerPlaceholder = 0;
     LayoutObject* nextLayoutObject = descendant->nextInPreOrderAfterChildren(this);
     if (nextLayoutObject) {
         adjacentNextSpannerPlaceholder = containingColumnSpannerPlaceholder(nextLayoutObject);
         if (!adjacentNextSpannerPlaceholder)
             return; // Followed by column content. Set still needed.
     }
     // We have now determined that, with the removal of |descendant|, we should remove a column
-    // set. Locate it and remove it. Do it without involving findSetLayoutObjects(), as that might be
-    // very slow. Deduce the right set from the spanner placeholders that we've already found.
+    // set. Locate it and remove it. Do it without involving mapDescendantToColumnSet(), as that
+    // might be very slow. Deduce the right set from the spanner placeholders that we've already
+    // found.
     LayoutMultiColumnSet* columnSetToRemove;
     if (adjacentNextSpannerPlaceholder) {
         columnSetToRemove = toLayoutMultiColumnSet(adjacentNextSpannerPlaceholder->previousSiblingMultiColumnBox());
         ASSERT(!adjacentPreviousSpannerPlaceholder || columnSetToRemove == adjacentPreviousSpannerPlaceholder->nextSiblingMultiColumnBox());
     } else if (adjacentPreviousSpannerPlaceholder) {
         columnSetToRemove = toLayoutMultiColumnSet(adjacentPreviousSpannerPlaceholder->nextSiblingMultiColumnBox());
     } else {
         // If there were no adjacent spanners, it has to mean that there's only one column set,
         // since it's only spanners that may cause creation of multiple sets.
         columnSetToRemove = firstMultiColumnSet();
@@ skipping 92 matching lines @@
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }