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

Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 68 matching lines @@
 using namespace HTMLNames;
 
 struct SameSizeAsLayoutBlock : public LayoutBox {
     LayoutObjectChildList children;
     LineBoxList lineBoxes;
     uint32_t bitfields;
 };
 
 static_assert(sizeof(LayoutBlock) == sizeof(SameSizeAsLayoutBlock), "LayoutBlock should stay small");
 
-static TrackedDescendantsMap* gPositionedDescendantsMap = 0;
-static TrackedDescendantsMap* gPercentHeightDescendantsMap = 0;
+static TrackedDescendantsMap* gPositionedDescendantsMap = nullptr;
+static TrackedDescendantsMap* gPercentHeightDescendantsMap = nullptr;
 
-static TrackedContainerMap* gPositionedContainerMap = 0;
-static TrackedContainerMap* gPercentHeightContainerMap = 0;
+static TrackedContainerMap* gPositionedContainerMap = nullptr;
+static TrackedContainerMap* gPercentHeightContainerMap = nullptr;
 
 typedef WTF::HashSet<LayoutBlock*> DelayedUpdateScrollInfoSet;
 static int gDelayUpdateScrollInfo = 0;
-static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = 0;
+static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = nullptr;
 
 // This class helps dispatching the 'overflow' event on layout change. overflow can be set on LayoutBoxes, yet the existing code
 // only works on LayoutBlocks. If this changes, this class should be shared with other LayoutBoxes.
 class OverflowEventDispatcher {
     WTF_MAKE_NONCOPYABLE(OverflowEventDispatcher);
 public:
     OverflowEventDispatcher(const LayoutBlock* block)
         : m_block(block)
         , m_hadHorizontalLayoutOverflow(false)
         , m_hadVerticalLayoutOverflow(false)
@@ skipping 115 matching lines @@
     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
     // properly dirty line boxes that they are removed from. Effects that do :before/:after only on hover could crash otherwise.
     children()->destroyLeftoverChildren();
 
     // Destroy our continuation before anything other than anonymous children.
     // The reason we don't destroy it before anonymous children is that they may
     // have continuations of their own that are anonymous children of our continuation.
     LayoutBoxModelObject* continuation = this->continuation();
     if (continuation) {
         continuation->destroy();
-        setContinuation(0);
+        setContinuation(nullptr);
     }
 
     if (!documentBeingDestroyed()) {
         if (firstLineBox()) {
             // We can't wait for LayoutBox::destroy to clear the selection,
             // because by then we will have nuked the line boxes.
             // FIXME: The FrameSelection should be responsible for this when it
             // is notified of DOM mutations.
             if (isSelectionBorder())
                 view()->clearSelection();
@@ skipping 461 matching lines @@
             children()->removeChildNode(this, inlineChildrenBlock, inlineChildrenBlockHasLayer);
 
             // Now just put the inlineChildrenBlock inside the blockChildrenBlock.
             blockChildrenBlock->children()->insertChildNode(blockChildrenBlock, inlineChildrenBlock, prev == inlineChildrenBlock ? blockChildrenBlock->firstChild() : 0,
                 inlineChildrenBlockHasLayer || blockChildrenBlock->hasLayer());
             next->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
 
             // inlineChildrenBlock got reparented to blockChildrenBlock, so it is no longer a child
             // of "this". we null out prev or next so that is not used later in the function.
             if (inlineChildrenBlock == prevBlock)
-                prev = 0;
+                prev = nullptr;
             else
-                next = 0;
+                next = nullptr;
         } else {
             // Take all the children out of the |next| block and put them in
             // the |prev| block.
             nextBlock->moveAllChildrenIncludingFloatsTo(prevBlock, nextBlock->hasLayer() || prevBlock->hasLayer());
 
             // Delete the now-empty block's lines and nuke it.
             nextBlock->deleteLineBoxTree();
             nextBlock->destroy();
-            next = 0;
+            next = nullptr;
         }
     }
 
     LayoutBox::removeChild(oldChild);
 
     LayoutObject* child = prev ? prev : next;
     if (canMergeAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling() && canCollapseAnonymousBlockChild()) {
         // The removal has knocked us down to containing only a single anonymous
         // box.  We can go ahead and pull the content right back up into our
         // box.
@@ skipping 30 matching lines @@
                 LayoutBoxModelObject* nextContinuation = continuation();
                 if (curr->isLayoutInline())
                     toLayoutInline(curr)->setContinuation(nextContinuation);
                 else if (curr->isLayoutBlock())
                     toLayoutBlock(curr)->setContinuation(nextContinuation);
                 else
                     ASSERT_NOT_REACHED();
 
                 break;
             }
-            setContinuation(0);
+            setContinuation(nullptr);
             destroy();
         }
     }
 }
 
 bool LayoutBlock::isSelfCollapsingBlock() const
 {
     // We are not self-collapsing if we
     // (a) have a non-zero height according to layout (an optimization to avoid wasting time)
     // (b) are a table,
@@ skipping 65 matching lines @@
 }
 
 void LayoutBlock::finishDelayUpdateScrollInfo()
 {
     --gDelayUpdateScrollInfo;
     ASSERT(gDelayUpdateScrollInfo >= 0);
     if (gDelayUpdateScrollInfo == 0) {
         ASSERT(gDelayedUpdateScrollInfoSet);
 
         OwnPtr<DelayedUpdateScrollInfoSet> infoSet(adoptPtr(gDelayedUpdateScrollInfoSet));
-        gDelayedUpdateScrollInfoSet = 0;
+        gDelayedUpdateScrollInfoSet = nullptr;
 
         for (auto* block : *infoSet) {
             if (block->hasOverflowClip()) {
                 block->layer()->scrollableArea()->updateAfterLayout();
             }
         }
     }
 }
 
 void LayoutBlock::updateScrollInfoAfterLayout()
@@ skipping 508 matching lines @@
 {
     // The border can potentially be further extended by our containingBlock().
     if (rootBlock != this)
         return containingBlock()->logicalRightSelectionOffset(rootBlock, position + logicalTop());
     return logicalRightOffsetForContent();
 }
 
 LayoutBlock* LayoutBlock::blockBeforeWithinSelectionRoot(LayoutSize& offset) const
 {
     if (isSelectionRoot())
-        return 0;
+        return nullptr;
 
     const LayoutObject* object = this;
     LayoutObject* sibling;
     do {
         sibling = object->previousSibling();
         while (sibling && (!sibling->isLayoutBlock() || toLayoutBlock(sibling)->isSelectionRoot()))
             sibling = sibling->previousSibling();
 
         offset -= LayoutSize(toLayoutBlock(object)->logicalLeft(), toLayoutBlock(object)->logicalTop());
         object = object->parent();
     } while (!sibling && object && object->isLayoutBlock() && !toLayoutBlock(object)->isSelectionRoot());
 
     if (!sibling)
-        return 0;
+        return nullptr;
 
     LayoutBlock* beforeBlock = toLayoutBlock(sibling);
 
     offset += LayoutSize(beforeBlock->logicalLeft(), beforeBlock->logicalTop());
 
     LayoutObject* child = beforeBlock->lastChild();
     while (child && child->isLayoutBlock()) {
         beforeBlock = toLayoutBlock(child);
         offset += LayoutSize(beforeBlock->logicalLeft(), beforeBlock->logicalTop());
         child = beforeBlock->lastChild();
@@ skipping 61 matching lines @@
         descendantSet->remove(descendant);
         if (descendantSet->isEmpty())
             descendantsMap->remove(descendantsMapIterator);
     }
 }
 
 TrackedLayoutBoxListHashSet* LayoutBlock::positionedObjects() const
 {
     if (gPositionedDescendantsMap)
         return gPositionedDescendantsMap->get(this);
-    return 0;
+    return nullptr;
 }
 
 void LayoutBlock::insertPositionedObject(LayoutBox* o)
 {
     ASSERT(!isAnonymousBlock());
     insertIntoTrackedLayoutBoxMaps(o, gPositionedDescendantsMap, gPositionedContainerMap);
 }
 
 void LayoutBlock::removePositionedObject(LayoutBox* o)
 {
@@ skipping 327 matching lines @@
 {
     ASSERT(childrenInline());
 
     if (!firstRootBox())
         return createPositionWithAffinity(0, DOWNSTREAM);
 
     bool linesAreFlipped = style()->isFlippedLinesWritingMode();
     bool blocksAreFlipped = style()->isFlippedBlocksWritingMode();
 
     // look for the closest line box in the root box which is at the passed-in y coordinate
-    InlineBox* closestBox = 0;
-    RootInlineBox* firstRootBoxWithChildren = 0;
-    RootInlineBox* lastRootBoxWithChildren = 0;
+    InlineBox* closestBox = nullptr;
+    RootInlineBox* firstRootBoxWithChildren = nullptr;
+    RootInlineBox* lastRootBoxWithChildren = nullptr;
     for (RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox()) {
         if (!root->firstLeafChild())
             continue;
         if (!firstRootBoxWithChildren)
             firstRootBoxWithChildren = root;
 
         if (!linesAreFlipped && root->isFirstAfterPageBreak() && (pointInLogicalContents.y() < root->lineTopWithLeading()
             || (blocksAreFlipped && pointInLogicalContents.y() == root->lineTopWithLeading())))
             break;
 
@@ skipping 477 matching lines @@
             || !parentBlock
             || !isLayoutBlockFlowOrLayoutButton(parentBlock))
             break;
         ASSERT_WITH_SECURITY_IMPLICATION(parentBlock->isLayoutBlock());
         if (toLayoutBlock(parentBlock)->firstChild() != firstLineBlock)
             break;
         firstLineBlock = toLayoutBlock(parentBlock);
     }
 
     if (!hasPseudo)
-        return 0;
+        return nullptr;
 
     return firstLineBlock;
 }
 
 // Helper methods for obtaining the last line, computing line counts and heights for line counts
 // (crawling into blocks).
 static bool shouldCheckLines(LayoutObject* obj)
 {
     return !obj->isFloatingOrOutOfFlowPositioned()
         && obj->isLayoutBlock() && obj->style()->height().isAuto()
         && (!obj->isDeprecatedFlexibleBox() || obj->style()->boxOrient() == VERTICAL);
 }
 
 static int getHeightForLineCount(LayoutBlock* block, int l, bool includeBottom, int& count)
 {
     if (block->style()->visibility() == VISIBLE) {
         if (block->isLayoutBlockFlow() && block->childrenInline()) {
             for (RootInlineBox* box = toLayoutBlockFlow(block)->firstRootBox(); box; box = box->nextRootBox()) {
                 if (++count == l)
                     return box->lineBottom() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
             }
         } else {
-            LayoutBox* normalFlowChildWithoutLines = 0;
+            LayoutBox* normalFlowChildWithoutLines = nullptr;
             for (LayoutBox* obj = block->firstChildBox(); obj; obj = obj->nextSiblingBox()) {
                 if (shouldCheckLines(obj)) {
                     int result = getHeightForLineCount(toLayoutBlock(obj), l, false, count);
                     if (result != -1)
                         return result + obj->location().y() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
                 } else if (!obj->isFloatingOrOutOfFlowPositioned()) {
                     normalFlowChildWithoutLines = obj;
                 }
             }
             if (normalFlowChildWithoutLines && l == 0)
                 return normalFlowChildWithoutLines->location().y() + normalFlowChildWithoutLines->size().height();
         }
     }
 
     return -1;
 }
 
 RootInlineBox* LayoutBlock::lineAtIndex(int i) const
 {
     ASSERT(i >= 0);
 
     if (style()->visibility() != VISIBLE)
-        return 0;
+        return nullptr;
 
     if (childrenInline()) {
         for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {
             if (!i--)
                 return box;
         }
     } else {
         for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
             if (!shouldCheckLines(child))
                 continue;
             if (RootInlineBox* box = toLayoutBlock(child)->lineAtIndex(i))
                 return box;
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 int LayoutBlock::lineCount(const RootInlineBox* stopRootInlineBox, bool* found) const
 {
     int count = 0;
 
     if (style()->visibility() == VISIBLE) {
         if (childrenInline()) {
             for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {
                 count++;
@@ skipping 325 matching lines @@
 const char* LayoutBlock::name() const
 {
     ASSERT_NOT_REACHED();
     return "LayoutBlock";
 }
 
 LayoutBlock* LayoutBlock::createAnonymousWithParentAndDisplay(const LayoutObject* parent, EDisplay display)
 {
     // FIXME: Do we need to convert all our inline displays to block-type in the anonymous logic ?
     EDisplay newDisplay;
-    LayoutBlock* newBox = 0;
+    LayoutBlock* newBox = nullptr;
     if (display == FLEX || display == INLINE_FLEX) {
         newBox = LayoutFlexibleBox::createAnonymous(&parent->document());
         newDisplay = FLEX;
     } else {
         newBox = LayoutBlockFlow::createAnonymous(&parent->document());
         newDisplay = BLOCK;
     }
 
     RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(parent->styleRef(), newDisplay);
     parent->updateAnonymousChildStyle(*newBox, *newStyle);
@@ skipping 152 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink