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

Source/core/layout/LayoutInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 42 matching lines @@
 static_assert(sizeof(LayoutInline) == sizeof(SameSizeAsLayoutInline), "LayoutInline should stay small");
 
 LayoutInline::LayoutInline(Element* element)
     : LayoutBoxModelObject(element)
 {
     setChildrenInline(true);
 }
 
 LayoutInline* LayoutInline::createAnonymous(Document* document)
 {
-    LayoutInline* layoutObject = new LayoutInline(0);
+    LayoutInline* layoutObject = new LayoutInline(nullptr);
     layoutObject->setDocumentForAnonymous(document);
     return layoutObject;
 }
 
 void LayoutInline::willBeDestroyed()
 {
 #if ENABLE(ASSERT)
     // Make sure we do not retain "this" in the continuation outline table map of our containing blocks.
     if (parent() && style()->visibility() == VISIBLE && style()->hasOutline()) {
         bool containingBlockPaintsContinuationOutline = continuation() || isInlineElementContinuation();
         if (containingBlockPaintsContinuationOutline) {
             if (LayoutBlock* cb = containingBlock()) {
                 if (LayoutBlock* cbCb = cb->containingBlock())
                     ASSERT(!cbCb->paintsContinuationOutline(this));
             }
         }
     }
 #endif
 
     // 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 LayoutBoxModelObject::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 37 matching lines @@
     setHasReflection(false);
 }
 
 static LayoutObject* inFlowPositionedInlineAncestor(LayoutObject* p)
 {
     while (p && p->isLayoutInline()) {
         if (p->isRelPositioned())
             return p;
         p = p->parent();
     }
-    return 0;
+    return nullptr;
 }
 
 static void updateStyleOfAnonymousBlockContinuations(LayoutObject* block, const ComputedStyle& newStyle, const ComputedStyle& oldStyle)
 {
     for (;block && block->isAnonymousBlock(); block = block->nextSibling()) {
         if (!toLayoutBlock(block)->isAnonymousBlockContinuation())
             continue;
 
         RefPtr<ComputedStyle> newBlockStyle;
 
@@ skipping 25 matching lines @@
     // Ensure that all of the split inlines pick up the new style. We
     // only do this if we're an inline, since we don't want to propagate
     // a block's style to the other inlines.
     // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
     // and after the block share the same style, but the block doesn't
     // need to pass its style on to anyone else.
     const ComputedStyle& newStyle = styleRef();
     LayoutInline* continuation = inlineElementContinuation();
     for (LayoutInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
         LayoutBoxModelObject* nextCont = currCont->continuation();
-        currCont->setContinuation(0);
+        currCont->setContinuation(nullptr);
         currCont->setStyle(mutableStyle());
         currCont->setContinuation(nextCont);
     }
 
     // If an inline's outline or in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
     // Do this by updating the styles of the descendant blocks' containing anonymous blocks - there may be more than one.
     if (continuation && oldStyle
         && (!newStyle.isOutlineEquivalent(oldStyle)
             || (newStyle.position() != oldStyle->position() && (newStyle.hasInFlowPosition() || oldStyle->hasInFlowPosition())))) {
         // If any descendant blocks exist then they will be in the next anonymous block and its siblings.
@@ skipping 242 matching lines @@
     middleBlock->setContinuation(cloneInline);
 
     // Now take all of the children from |beforeChild| to the end and remove
     // them from |this| and place them in the clone.
     moveChildrenToIgnoringContinuation(cloneInline, beforeChild);
 }
 
 void LayoutInline::splitFlow(LayoutObject* beforeChild, LayoutBlock* newBlockBox,
     LayoutObject* newChild, LayoutBoxModelObject* oldCont)
 {
-    LayoutBlock* pre = 0;
+    LayoutBlock* pre = nullptr;
     LayoutBlock* block = containingBlock();
 
     // Delete our line boxes before we do the inline split into continuations.
     block->deleteLineBoxTree();
 
     bool madeNewBeforeBlock = false;
     if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
         // We can reuse this block and make it the preBlock of the next continuation.
         pre = block;
-        pre->removePositionedObjects(0);
+        pre->removePositionedObjects(nullptr);
         if (pre->isLayoutBlockFlow())
             toLayoutBlockFlow(pre)->removeFloatingObjects();
         block = block->containingBlock();
     } else {
         // No anonymous block available for use.  Make one.
         pre = block->createAnonymousBlock();
         madeNewBeforeBlock = true;
     }
 
     LayoutBlock* post = toLayoutBlock(pre->createAnonymousBoxWithSameTypeAs(block));
@@ skipping 28 matching lines @@
     // make new line boxes instead of leaving the old line boxes around.
     pre->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
     block->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
     post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
 }
 
 void LayoutInline::addChildToContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     LayoutBoxModelObject* flow = continuationBefore(beforeChild);
     ASSERT(!beforeChild || beforeChild->parent()->isLayoutBlock() || beforeChild->parent()->isLayoutInline());
-    LayoutBoxModelObject* beforeChildParent = 0;
+    LayoutBoxModelObject* beforeChildParent = nullptr;
     if (beforeChild) {
         beforeChildParent = toLayoutBoxModelObject(beforeChild->parent());
     } else {
         LayoutBoxModelObject* cont = nextContinuation(flow);
         if (cont)
             beforeChildParent = cont;
         else
             beforeChildParent = flow;
     }
 
@@ skipping 379 matching lines @@
             LayoutInline* currInline = toLayoutInline(curr);
             InlineBox* result = currInline->firstLineBoxIncludingCulling();
             if (result)
                 return result;
         } else if (curr->isText()) {
             LayoutText* currText = toLayoutText(curr);
             if (currText->firstTextBox())
                 return currText->firstTextBox();
         }
     }
-    return 0;
+    return nullptr;
 }
 
 InlineBox* LayoutInline::culledInlineLastLineBox() const
 {
     for (LayoutObject* curr = lastChild(); curr; curr = curr->previousSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox())
             return toLayoutBox(curr)->inlineBoxWrapper();
         if (curr->isLayoutInline()) {
             LayoutInline* currInline = toLayoutInline(curr);
             InlineBox* result = currInline->lastLineBoxIncludingCulling();
             if (result)
                 return result;
         } else if (curr->isText()) {
             LayoutText* currText = toLayoutText(curr);
             if (currText->lastTextBox())
                 return currText->lastTextBox();
         }
     }
-    return 0;
+    return nullptr;
 }
 
 LayoutRect LayoutInline::culledInlineVisualOverflowBoundingBox() const
 {
     FloatRect floatResult;
     LinesBoundingBoxGeneratorContext context(floatResult);
     generateCulledLineBoxRects(context, this);
     LayoutRect result(enclosingLayoutRect(floatResult));
     bool isHorizontal = style()->isHorizontalWritingMode();
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
@@ skipping 477 matching lines @@
 }
 
 void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink