Add isMultiColumnContainer() for convenience and readability.

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 55 matching lines @@
 
 LayoutMultiColumnSet* LayoutMultiColumnFlowThread::lastMultiColumnSet() const
 {
     for (LayoutObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isLayoutMultiColumnSet())
             return toLayoutMultiColumnSet(sibling);
     }
     return nullptr;
 }
 
+static inline bool isMultiColumnContainer(const LayoutObject& object)
+{
+    if (!object.isLayoutBlockFlow())
+        return false;
+    return toLayoutBlockFlow(object).multiColumnFlowThread();
+}
+
 // Find the next layout object that has the multicol container in its containing block chain, skipping nested multicol containers.
 static LayoutObject* nextInPreOrderAfterChildrenSkippingOutOfFlow(LayoutMultiColumnFlowThread* flowThread, LayoutObject* descendant)
 {
     ASSERT(descendant->isDescendantOf(flowThread));
     LayoutObject* object = descendant->nextInPreOrderAfterChildren(flowThread);
     while (object) {
         // Walk through the siblings and find the first one which is either in-flow or has this
         // flow thread as its containing block flow thread.
         if (!object->isOutOfFlowPositioned())
             break;
         if (object->containingBlock()->flowThreadContainingBlock() == flowThread) {
             // This out-of-flow object is still part of the flow thread, because its containing
             // block (probably relatively positioned) is part of the flow thread.
             break;
         }
         object = object->nextInPreOrderAfterChildren(flowThread);
     }
     if (!object)
         return nullptr;
 #if ENABLE(ASSERT)
     // Make sure that we didn't stumble into an inner multicol container.
     for (LayoutObject* walker = object->parent(); walker && walker != flowThread; walker = walker->parent())
-        ASSERT(!walker->isLayoutBlockFlow() || !toLayoutBlockFlow(walker)->multiColumnFlowThread());
+        ASSERT(!isMultiColumnContainer(*walker));
 #endif
     return object;
 }
 
 // Find the previous layout object that has the multicol container in its containing block chain, skipping nested multicol containers.
 static LayoutObject* previousInPreOrderSkippingOutOfFlow(LayoutMultiColumnFlowThread* flowThread, LayoutObject* descendant)
 {
     ASSERT(descendant->isDescendantOf(flowThread));
     LayoutObject* object = descendant->previousInPreOrder(flowThread);
     while (object && object != flowThread) {
         if (object->isColumnSpanAll()) {
             LayoutMultiColumnFlowThread* placeholderFlowThread = toLayoutBox(object)->spannerPlaceholder()->flowThread();
             if (placeholderFlowThread == flowThread)
                 break;
             // We're inside an inner multicol container. We have no business there. Continue on the outside.
             object = placeholderFlowThread->parent();
             ASSERT(object->isDescendantOf(flowThread));
             continue;
         }
         if (object->flowThreadContainingBlock() == flowThread) {
             LayoutObject* ancestor;
             for (ancestor = object->parent(); ; ancestor = ancestor->parent()) {
                 if (ancestor == flowThread)
                     return object;
-                if (ancestor->isLayoutBlockFlow() && toLayoutBlockFlow(ancestor)->multiColumnFlowThread()) {
+                if (isMultiColumnContainer(*ancestor)) {
                     // We're inside an inner multicol container. We have no business there.
                     break;
                 }
             }
             object = ancestor;
             ASSERT(ancestor->isDescendantOf(flowThread));
             continue; // Continue on the outside of the inner flow thread.
         }
         // We're inside something that's out-of-flow. Keep looking upwards and backwards in the tree.
         object = object->previousInPreOrder(flowThread);
     }
     if (!object || object == flowThread)
         return nullptr;
 #if ENABLE(ASSERT)
     // Make sure that we didn't stumble into an inner multicol container.
     for (LayoutObject* walker = object->parent(); walker && walker != flowThread; walker = walker->parent())
-        ASSERT(!walker->isLayoutBlockFlow() || !toLayoutBlockFlow(walker)->multiColumnFlowThread());
+        ASSERT(!isMultiColumnContainer(*walker));
 #endif
     return object;
 }
 
 static LayoutObject* firstLayoutObjectInSet(LayoutMultiColumnSet* multicolSet)
 {
     LayoutBox* 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
@@ skipping 731 matching lines @@
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }