C++11: Replace 0 with nullptr where applicable in layout code.

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 14 matching lines @@
 
 #include "config.h"
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 
 namespace blink {
 
 LayoutMultiColumnFlowThread::LayoutMultiColumnFlowThread()
-    : m_lastSetWorkedOn(0)
+    : m_lastSetWorkedOn(nullptr)
     , m_columnCount(1)
     , m_columnHeightAvailable(0)
     , m_inBalancingPass(false)
     , m_needsColumnHeightsRecalculation(false)
     , m_progressionIsInline(true)
     , m_isBeingEvacuated(false)
 {
     setIsInsideFlowThread(true);
 }
 
 LayoutMultiColumnFlowThread::~LayoutMultiColumnFlowThread()
 {
 }
 
 LayoutMultiColumnFlowThread* LayoutMultiColumnFlowThread::createAnonymous(Document& document, const ComputedStyle& parentStyle)
 {
     LayoutMultiColumnFlowThread* layoutObject = new LayoutMultiColumnFlowThread();
     layoutObject->setDocumentForAnonymous(&document);
     layoutObject->setStyle(ComputedStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK));
     return layoutObject;
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnFlowThread::firstMultiColumnSet() const
 {
     for (LayoutObject* sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
         if (sibling->isLayoutMultiColumnSet())
             return toLayoutMultiColumnSet(sibling);
     }
-    return 0;
+    return nullptr;
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnFlowThread::lastMultiColumnSet() const
 {
     for (LayoutObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isLayoutMultiColumnSet())
             return toLayoutMultiColumnSet(sibling);
     }
-    return 0;
+    return nullptr;
 }
 
 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())
@@ skipping 36 matching lines @@
     // of them contains then.
     ASSERT(sibling->isLayoutMultiColumnSpannerPlaceholder());
     LayoutBox* spanner = toLayoutMultiColumnSpannerPlaceholder(sibling)->layoutObjectInFlowThread();
     return nextInPreOrderAfterChildrenSkippingOutOfFlow(multicolSet->multiColumnFlowThread(), spanner);
 }
 
 static LayoutObject* lastLayoutObjectInSet(LayoutMultiColumnSet* multicolSet)
 {
     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.
+        return nullptr; // 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());
     LayoutBox* spanner = toLayoutMultiColumnSpannerPlaceholder(sibling)->layoutObjectInFlowThread();
     return previousInPreOrderSkippingOutOfFlow(multicolSet->multiColumnFlowThread(), spanner);
 }
 
 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));
     ASSERT(layoutObject->containingBlock()->isDescendantOf(this)); // Out-of-flow objects don't belong in column sets.
     LayoutMultiColumnSet* multicolSet = firstMultiColumnSet();
     if (!multicolSet)
-        return 0;
+        return nullptr;
     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()) {
         LayoutObject* firstLayoutObject = firstLayoutObjectInSet(multicolSet);
         LayoutObject* lastLayoutObject = lastLayoutObjectInSet(multicolSet);
         ASSERT(firstLayoutObject);
 
         for (LayoutObject* walker = firstLayoutObject; walker; walker = walker->nextInPreOrder(this)) {
             if (walker == layoutObject)
                 return multicolSet;
             if (walker == lastLayoutObject)
                 break;
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 LayoutMultiColumnSpannerPlaceholder* LayoutMultiColumnFlowThread::containingColumnSpannerPlaceholder(const LayoutObject* 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.
     LayoutBox* firstBox = firstMultiColumnBox();
     if (!firstBox || (firstBox == lastMultiColumnBox() && firstBox->isLayoutMultiColumnSet()))
-        return 0;
+        return nullptr;
 
     // We have spanners. See if the layoutObject in question is one or inside of one then.
     for (const LayoutObject* ancestor = descendant; ancestor && ancestor != this; ancestor = ancestor->parent()) {
         if (LayoutMultiColumnSpannerPlaceholder* placeholder = ancestor->spannerPlaceholder())
             return placeholder;
     }
-    return 0;
+    return nullptr;
 }
 
 void LayoutMultiColumnFlowThread::populate()
 {
     LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
     ASSERT(!nextSibling());
     // Reparent children preceding the flow thread into the flow thread. It's multicol content
     // now. At this point there's obviously nothing after the flow thread, but layoutObjects (column
     // sets and spanners) will be inserted there as we insert elements into the flow thread.
     multicolContainer->moveChildrenTo(this, multicolContainer->firstChild(), this, true);
@@ skipping 73 matching lines @@
             LayoutMultiColumnSet* previousSet = columnSet->previousSiblingMultiColumnSet();
             if (!previousSet)
                 break;
             columnSet = previousSet;
         }
         return columnSet;
     }
 
     ASSERT(!m_columnSetsInvalidated);
     if (m_multiColumnSetList.isEmpty())
-        return 0;
+        return nullptr;
     if (offset <= 0)
         return m_multiColumnSetList.first();
 
     MultiColumnSetSearchAdapter adapter(offset);
     m_multiColumnSetIntervalTree.allOverlapsWithAdapter<MultiColumnSetSearchAdapter>(adapter);
 
     // If no set was found, the offset is in the flow thread overflow.
     if (!adapter.result() && !m_multiColumnSetList.isEmpty())
         return m_multiColumnSetList.last();
     return adapter.result();
@@ skipping 251 matching lines @@
     for (LayoutObject* layoutObject = descendant; layoutObject; layoutObject = next) {
         if (shouldSkipInsertedOrRemovedChild(this, *layoutObject)) {
             next = layoutObject->nextInPreOrderAfterChildren(descendant);
             continue;
         }
         next = layoutObject->nextInPreOrder(descendant);
         if (containingColumnSpannerPlaceholder(layoutObject))
             continue; // Inside a column spanner. Nothing to do, then.
         if (descendantIsValidColumnSpanner(layoutObject)) {
             // This layoutObject is a spanner, so it needs to establish a spanner placeholder.
-            LayoutBox* insertBefore = 0;
-            LayoutMultiColumnSet* setToSplit = 0;
+            LayoutBox* insertBefore = nullptr;
+            LayoutMultiColumnSet* setToSplit = nullptr;
             if (objectAfterSubtree) {
                 // The spanner is inserted before something. Figure out what this entails. If the
                 // next layoutObject is a spanner too, it means that we can simply insert a new spanner
                 // placeholder in front of its placeholder.
                 insertBefore = objectAfterSubtree->spannerPlaceholder();
                 if (!insertBefore) {
                     // The next layoutObject isn't a spanner; it's regular column content. Examine what
                     // comes right before us in the flow thread, then.
                     LayoutObject* previousLayoutObject = previousInPreOrderSkippingOutOfFlow(this, layoutObject);
                     if (!previousLayoutObject || previousLayoutObject == this) {
@@ skipping 78 matching lines @@
                 previousColumnBox->setNeedsLayout(LayoutInvalidationReason::ColumnsChanged);
                 invalidateColumnSets();
             }
         }
         placeholder->destroy();
     }
     if (hadContainingPlaceholder || !processedSomething)
         return; // No column content will be removed, so we can stop here.
 
     // Column content will be removed. Does this mean that we should destroy a column set?
-    LayoutMultiColumnSpannerPlaceholder* adjacentPreviousSpannerPlaceholder = 0;
+    LayoutMultiColumnSpannerPlaceholder* adjacentPreviousSpannerPlaceholder = nullptr;
     LayoutObject* previousLayoutObject = previousInPreOrderSkippingOutOfFlow(this, descendant);
     if (previousLayoutObject && previousLayoutObject != this) {
         adjacentPreviousSpannerPlaceholder = containingColumnSpannerPlaceholder(previousLayoutObject);
         if (!adjacentPreviousSpannerPlaceholder)
             return; // Preceded by column content. Set still needed.
     }
-    LayoutMultiColumnSpannerPlaceholder* adjacentNextSpannerPlaceholder = 0;
+    LayoutMultiColumnSpannerPlaceholder* adjacentNextSpannerPlaceholder = nullptr;
     LayoutObject* nextLayoutObject = nextInPreOrderAfterChildrenSkippingOutOfFlow(this, descendant);
     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 mapDescendantToColumnSet(), as that
     // might be very slow. Deduce the right set from the spanner placeholders that we've already
     // found.
@@ skipping 89 matching lines @@
     if (m_lastSetWorkedOn)
         m_lastSetWorkedOn->beginFlow(LayoutUnit());
     LayoutFlowThread::layout();
     if (LayoutMultiColumnSet* lastSet = lastMultiColumnSet()) {
         ASSERT(lastSet == m_lastSetWorkedOn);
         if (!lastSet->nextSiblingMultiColumnBox()) {
             lastSet->endFlow(logicalHeight());
             lastSet->expandToEncompassFlowThreadContentsIfNeeded();
         }
     }
-    m_lastSetWorkedOn = 0;
+    m_lastSetWorkedOn = nullptr;
 }
 
 void LayoutMultiColumnFlowThread::setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage)
 {
     // Only positive values are interesting (and allowed) here. Zero space shortage may be reported
     // when we're at the top of a column and the element has zero height. Ignore this, and also
     // ignore any negative values, which may occur when we set an early break in order to honor
     // widows in the next column.
     if (spaceShortage <= 0)
         return;
@@ skipping 20 matching lines @@
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }