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

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 126 matching lines @@
     unsigned m_bitfields2;
     LayoutRect rect; // Stores the previous paint invalidation rect.
     LayoutPoint position; // Stores the previous position from the paint invalidation container.
 };
 
 static_assert(sizeof(LayoutObject) == sizeof(SameSizeAsLayoutObject), "LayoutObject should stay small");
 
 bool LayoutObject::s_affectsParentBlock = false;
 
 typedef HashMap<const LayoutObject*, LayoutRect> SelectionPaintInvalidationMap;
-static SelectionPaintInvalidationMap* selectionPaintInvalidationMap = 0;
+static SelectionPaintInvalidationMap* selectionPaintInvalidationMap = nullptr;
 
 void* LayoutObject::operator new(size_t sz)
 {
     ASSERT(isMainThread());
     return partitionAlloc(WTF::Partitions::getRenderingPartition(), sz);
 }
 
 void LayoutObject::operator delete(void* ptr)
 {
     ASSERT(isMainThread());
@@ skipping 19 matching lines @@
             image->setIsGeneratedContent();
         } else {
             image->setImageResource(LayoutImageResource::create());
         }
         image->setStyleInternal(nullptr);
         return image;
     }
 
     switch (style.display()) {
     case NONE:
-        return 0;
+        return nullptr;
     case INLINE:
         return new LayoutInline(element);
     case BLOCK:
     case INLINE_BLOCK:
         return new LayoutBlockFlow(element);
     case LIST_ITEM:
         return new LayoutListItem(element);
     case TABLE:
     case INLINE_TABLE:
         return new LayoutTable(element);
@@ skipping 14 matching lines @@
     case INLINE_BOX:
         return new LayoutDeprecatedFlexibleBox(*element);
     case FLEX:
     case INLINE_FLEX:
         return new LayoutFlexibleBox(element);
     case GRID:
     case INLINE_GRID:
         return new LayoutGrid(element);
     }
 
-    return 0;
+    return nullptr;
 }
 
 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, layoutObjectCounter, ("LayoutObject"));
 unsigned LayoutObject::s_instanceCount = 0;
 
 LayoutObject::LayoutObject(Node* node)
     : ImageResourceClient()
     , m_style(nullptr)
     , m_node(node)
     , m_parent(nullptr)
@@ skipping 210 matching lines @@
 {
     if (LayoutObject* o = slowFirstChild())
         return o;
 
     return nextInPreOrderAfterChildren(stayWithin);
 }
 
 LayoutObject* LayoutObject::nextInPreOrderAfterChildren(const LayoutObject* stayWithin) const
 {
     if (this == stayWithin)
-        return 0;
+        return nullptr;
 
     const LayoutObject* current = this;
     LayoutObject* next = current->nextSibling();
     for (; !next; next = current->nextSibling()) {
         current = current->parent();
         if (!current || current == stayWithin)
-            return 0;
+            return nullptr;
     }
     return next;
 }
 
 LayoutObject* LayoutObject::previousInPreOrder() const
 {
     if (LayoutObject* o = previousSibling()) {
         while (LayoutObject* lastChild = o->slowLastChild())
             o = lastChild;
         return o;
     }
 
     return parent();
 }
 
 LayoutObject* LayoutObject::previousInPreOrder(const LayoutObject* stayWithin) const
 {
     if (this == stayWithin)
-        return 0;
+        return nullptr;
 
     return previousInPreOrder();
 }
 
 LayoutObject* LayoutObject::childAt(unsigned index) const
 {
     LayoutObject* child = slowFirstChild();
     for (unsigned i = 0; child && i < index; i++)
         child = child->nextSibling();
     return child;
 }
 
 LayoutObject* LayoutObject::lastLeafChild() const
 {
     LayoutObject* r = slowLastChild();
     while (r) {
-        LayoutObject* n = 0;
+        LayoutObject* n = nullptr;
         n = r->slowLastChild();
         if (!n)
             break;
         r = n;
     }
     return r;
 }
 
 static void addLayers(LayoutObject* obj, DeprecatedPaintLayer* parentLayer, LayoutObject*& newObject,
     DeprecatedPaintLayer*& beforeChild)
 {
     if (obj->hasLayer()) {
         if (!beforeChild && newObject) {
             // We need to figure out the layer that follows newObject. We only do
             // this the first time we find a child layer, and then we update the
             // pointer values for newObject and beforeChild used by everyone else.
             beforeChild = newObject->parent()->findNextLayer(parentLayer, newObject);
-            newObject = 0;
+            newObject = nullptr;
         }
         parentLayer->addChild(toLayoutBoxModelObject(obj)->layer(), beforeChild);
         return;
     }
 
     for (LayoutObject* curr = obj->slowFirstChild(); curr; curr = curr->nextSibling())
         addLayers(curr, parentLayer, newObject, beforeChild);
 }
 
 void LayoutObject::addLayers(DeprecatedPaintLayer* parentLayer)
 {
     if (!parentLayer)
         return;
 
     LayoutObject* object = this;
-    DeprecatedPaintLayer* beforeChild = 0;
+    DeprecatedPaintLayer* beforeChild = nullptr;
     blink::addLayers(this, parentLayer, object, beforeChild);
 }
 
 void LayoutObject::removeLayers(DeprecatedPaintLayer* parentLayer)
 {
     if (!parentLayer)
         return;
 
     if (hasLayer()) {
         parentLayer->removeChild(toLayoutBoxModelObject(this)->layer());
@@ skipping 22 matching lines @@
         curr->moveLayers(oldParent, newParent);
 }
 
 DeprecatedPaintLayer* LayoutObject::findNextLayer(DeprecatedPaintLayer* parentLayer, LayoutObject* startPoint, bool checkParent)
 {
     // Error check the parent layer passed in. If it's null, we can't find anything.
     if (!parentLayer)
         return 0;
 
     // Step 1: If our layer is a child of the desired parent, then return our layer.
-    DeprecatedPaintLayer* ourLayer = hasLayer() ? toLayoutBoxModelObject(this)->layer() : 0;
+    DeprecatedPaintLayer* ourLayer = hasLayer() ? toLayoutBoxModelObject(this)->layer() : nullptr;
     if (ourLayer && ourLayer->parent() == parentLayer)
         return ourLayer;
 
     // Step 2: If we don't have a layer, or our layer is the desired parent, then descend
     // into our siblings trying to find the next layer whose parent is the desired parent.
     if (!ourLayer || ourLayer == parentLayer) {
         for (LayoutObject* curr = startPoint ? startPoint->nextSibling() : slowFirstChild();
             curr; curr = curr->nextSibling()) {
-            DeprecatedPaintLayer* nextLayer = curr->findNextLayer(parentLayer, 0, false);
+            DeprecatedPaintLayer* nextLayer = curr->findNextLayer(parentLayer, nullptr, false);
             if (nextLayer)
                 return nextLayer;
         }
     }
 
     // Step 3: If our layer is the desired parent layer, then we're finished. We didn't
     // find anything.
     if (parentLayer == ourLayer)
-        return 0;
+        return nullptr;
 
     // Step 4: If |checkParent| is set, climb up to our parent and check its siblings that
     // follow us to see if we can locate a layer.
     if (checkParent && parent())
         return parent()->findNextLayer(parentLayer, this, true);
 
-    return 0;
+    return nullptr;
 }
 
 DeprecatedPaintLayer* LayoutObject::enclosingLayer() const
 {
     for (const LayoutObject* current = this; current; current = current->parent()) {
         if (current->hasLayer())
             return toLayoutBoxModelObject(current)->layer();
     }
     // FIXME: we should get rid of detached layout subtrees, at which point this code should
     // not be reached. crbug.com/411429
-    return 0;
+    return nullptr;
 }
 
 bool LayoutObject::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     LayoutBox* enclosingBox = this->enclosingBox();
     if (!enclosingBox)
         return false;
 
     enclosingBox->scrollRectToVisible(rect, alignX, alignY);
     return true;
 }
 
 LayoutBox* LayoutObject::enclosingBox() const
 {
     LayoutObject* curr = const_cast<LayoutObject*>(this);
     while (curr) {
         if (curr->isBox())
             return toLayoutBox(curr);
         curr = curr->parent();
     }
 
     ASSERT_NOT_REACHED();
-    return 0;
+    return nullptr;
 }
 
 LayoutBoxModelObject* LayoutObject::enclosingBoxModelObject() const
 {
     LayoutObject* curr = const_cast<LayoutObject*>(this);
     while (curr) {
         if (curr->isBoxModelObject())
             return toLayoutBoxModelObject(curr);
         curr = curr->parent();
     }
 
     ASSERT_NOT_REACHED();
-    return 0;
+    return nullptr;
 }
 
 LayoutBox* LayoutObject::enclosingScrollableBox() const
 {
     for (LayoutObject* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
         if (!ancestor->isBox())
             continue;
 
         LayoutBox* ancestorBox = toLayoutBox(ancestor);
         if (ancestorBox->canBeScrolledAndHasScrollableArea())
             return ancestorBox;
     }
 
-    return 0;
+    return nullptr;
 }
 
 LayoutFlowThread* LayoutObject::locateFlowThreadContainingBlock() const
 {
     ASSERT(isInsideFlowThread());
 
     // See if we have the thread cached because we're in the middle of layout.
     if (LayoutState* layoutState = view()->layoutState()) {
         if (LayoutFlowThread* flowThread = layoutState->flowThread())
             return flowThread;
@@ skipping 44 matching lines @@
         return false;
 
     if (RuntimeEnabledFeatures::slimmingPaintEnabled() && isDocumentElement())
         return !hasBoxEffect();
 
     return layoutObjectHasNoBoxEffectObsolete(*this);
 }
 
 LayoutBlock* LayoutObject::firstLineBlock() const
 {
-    return 0;
+    return nullptr;
 }
 
 static inline bool objectIsRelayoutBoundary(const LayoutObject* object)
 {
     // FIXME: In future it may be possible to broaden these conditions in order to improve performance.
     if (object->isTextControl())
         return true;
 
     if (object->isSVGRoot())
         return true;
@@ skipping 168 matching lines @@
         while (o && o->isAnonymousBlock())
             o = o->containingBlock();
     } else if (isColumnSpanAll()) {
         o = spannerPlaceholder()->containingBlock();
     } else {
         while (o && ((o->isInline() && !o->isReplaced()) || !o->isLayoutBlock()))
             o = o->parent();
     }
 
     if (!o || !o->isLayoutBlock())
-        return 0; // This can still happen in case of an orphaned tree
+        return nullptr; // This can still happen in case of an orphaned tree
 
     return toLayoutBlock(o);
 }
 
 bool LayoutObject::mustInvalidateFillLayersPaintOnHeightChange(const FillLayer& layer) const
 {
     // Nobody will use multiple layers without wanting fancy positioning.
     if (layer.next())
         return true;
 
@@ skipping 132 matching lines @@
     RELEASE_ASSERT(isRooted());
 
     const LayoutBoxModelObject* paintInvalidationContainer = containerForPaintInvalidation();
     ASSERT(paintInvalidationContainer);
 
     return *paintInvalidationContainer;
 }
 
 const LayoutBoxModelObject* LayoutObject::enclosingCompositedContainer() const
 {
-    LayoutBoxModelObject* container = 0;
+    LayoutBoxModelObject* container = nullptr;
     // FIXME: CompositingState is not necessarily up to date for many callers of this function.
     DisableCompositingQueryAsserts disabler;
 
     if (DeprecatedPaintLayer* compositingLayer = enclosingLayer()->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
         container = compositingLayer->layoutObject();
     return container;
 }
 
 const LayoutBoxModelObject* LayoutObject::adjustCompositedContainerForSpecialAncestors(const LayoutBoxModelObject* paintInvalidationContainer) const
 {
@@ skipping 993 matching lines @@
 
     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
 }
 
 const LayoutObject* LayoutObject::pushMappingToContainer(const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap) const
 {
     ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != this);
 
     LayoutObject* container = parent();
     if (!container)
-        return 0;
+        return nullptr;
 
     // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
     LayoutSize offset;
     if (container->hasOverflowClip())
         offset = -LayoutSize(toLayoutBox(container)->scrolledContentOffset());
 
     geometryMap.push(this, offset);
 
     return container;
 }
@@ skipping 119 matching lines @@
         *extraWidthToEndOfLine = 0;
 
     return LayoutRect();
 }
 
 void LayoutObject::computeLayerHitTestRects(LayerHitTestRects& layerRects) const
 {
     // Figure out what layer our container is in. Any offset (or new layer) for this
     // layoutObject within it's container will be applied in addLayerHitTestRects.
     LayoutPoint layerOffset;
-    const DeprecatedPaintLayer* currentLayer = 0;
+    const DeprecatedPaintLayer* currentLayer = nullptr;
 
     if (!hasLayer()) {
         LayoutObject* container = this->container();
         currentLayer = container->enclosingLayer();
         if (container && currentLayer->layoutObject() != container) {
             layerOffset.move(container->offsetFromAncestorContainer(currentLayer->layoutObject()));
             // If the layer itself is scrolled, we have to undo the subtraction of its scroll
             // offset since we want the offset relative to the scrolling content, not the
             // element itself.
             if (currentLayer->layoutObject()->hasOverflowClip())
@@ skipping 215 matching lines @@
 
     clearLayoutRootIfNeeded();
 }
 
 void LayoutObject::insertedIntoTree()
 {
     // FIXME: We should ASSERT(isRooted()) here but generated content makes some out-of-order insertion.
 
     // Keep our layer hierarchy updated. Optimize for the common case where we don't have any children
     // and don't have a layer attached to ourselves.
-    DeprecatedPaintLayer* layer = 0;
+    DeprecatedPaintLayer* layer = nullptr;
     if (slowFirstChild() || hasLayer()) {
         layer = parent()->enclosingLayer();
         addLayers(layer);
     }
 
     // If |this| is visible but this object was not, tell the layer it has some visible content
     // that needs to be drawn and layer visibility optimization can't be used
     if (parent()->style()->visibility() != VISIBLE && style()->visibility() == VISIBLE && !hasLayer()) {
         if (!layer)
             layer = parent()->enclosingLayer();
         if (layer)
             layer->dirtyVisibleContentStatus();
     }
 
     if (!isFloating() && parent()->childrenInline())
         parent()->dirtyLinesFromChangedChild(this);
 
     if (LayoutFlowThread* flowThread = flowThreadContainingBlock())
         flowThread->flowThreadDescendantWasInserted(this);
 }
 
 void LayoutObject::willBeRemovedFromTree()
 {
     // FIXME: We should ASSERT(isRooted()) but we have some out-of-order removals which would need to be fixed first.
 
     // If we remove a visible child from an invisible parent, we don't know the layer visibility any more.
-    DeprecatedPaintLayer* layer = 0;
+    DeprecatedPaintLayer* layer = nullptr;
     if (parent()->style()->visibility() != VISIBLE && style()->visibility() == VISIBLE && !hasLayer()) {
         layer = parent()->enclosingLayer();
         if (layer)
             layer->dirtyVisibleContentStatus();
     }
 
     // Keep our layer hierarchy updated.
     if (slowFirstChild() || hasLayer()) {
         if (!layer)
             layer = parent()->enclosingLayer();
@@ skipping 263 matching lines @@
 
     if (RefPtr<ComputedStyle> style = firstLineStyleForCachedUncachedType(Cached, isText() ? parent() : this, m_style.get()))
         return style.get();
 
     return m_style.get();
 }
 
 ComputedStyle* LayoutObject::getCachedPseudoStyle(PseudoId pseudo, const ComputedStyle* parentStyle) const
 {
     if (pseudo < FIRST_INTERNAL_PSEUDOID && !style()->hasPseudoStyle(pseudo))
-        return 0;
+        return nullptr;
 
     ComputedStyle* cachedStyle = style()->getCachedPseudoStyle(pseudo);
     if (cachedStyle)
         return cachedStyle;
 
     RefPtr<ComputedStyle> result = getUncachedPseudoStyle(PseudoStyleRequest(pseudo), parentStyle);
     if (result)
         return mutableStyleRef().addCachedPseudoStyle(result.release());
-    return 0;
+    return nullptr;
 }
 
 PassRefPtr<ComputedStyle> LayoutObject::getUncachedPseudoStyle(const PseudoStyleRequest& pseudoStyleRequest, const ComputedStyle* parentStyle, const ComputedStyle* ownStyle) const
 {
     if (pseudoStyleRequest.pseudoId < FIRST_INTERNAL_PSEUDOID && !ownStyle && !style()->hasPseudoStyle(pseudoStyleRequest.pseudoId))
         return nullptr;
 
     if (!parentStyle) {
         ASSERT(!ownStyle);
         parentStyle = style();
@@ skipping 27 matching lines @@
             }
         }
     }
 
     return getUncachedPseudoStyle(PseudoStyleRequest(SELECTION));
 }
 
 void LayoutObject::getTextDecorations(unsigned decorations, AppliedTextDecoration& underline, AppliedTextDecoration& overline, AppliedTextDecoration& linethrough, bool quirksMode, bool firstlineStyle)
 {
     LayoutObject* curr = this;
-    const ComputedStyle* styleToUse = 0;
+    const ComputedStyle* styleToUse = nullptr;
     unsigned currDecs = TextDecorationNone;
     Color resultColor;
     TextDecorationStyle resultStyle;
     do {
         styleToUse = curr->style(firstlineStyle);
         currDecs = styleToUse->textDecoration();
         currDecs &= decorations;
         resultColor = styleToUse->visitedDependentColor(CSSPropertyTextDecorationColor);
         resultStyle = styleToUse->textDecorationStyle();
         // Parameter 'decorations' is cast as an int to enable the bitwise operations below.
@@ skipping 120 matching lines @@
 }
 
 void LayoutObject::imageChanged(ImageResource* image, const IntRect* rect)
 {
     imageChanged(static_cast<WrappedImagePtr>(image), rect);
 }
 
 Element* LayoutObject::offsetParent() const
 {
     if (isDocumentElement() || isBody())
-        return 0;
+        return nullptr;
 
     if (isOutOfFlowPositioned() && style()->position() == FixedPosition)
-        return 0;
+        return nullptr;
 
     float effectiveZoom = style()->effectiveZoom();
-    Node* node = 0;
+    Node* node = nullptr;
     for (LayoutObject* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
         // Spec: http://www.w3.org/TR/cssom-view/#offset-attributes
 
         node = ancestor->node();
 
         if (!node)
             continue;
 
         if (ancestor->isPositioned())
             break;
 
         if (isHTMLBodyElement(*node))
             break;
 
         if (!isPositioned() && (isHTMLTableElement(*node) || isHTMLTableCellElement(*node)))
             break;
 
         // Webkit specific extension where offsetParent stops at zoom level changes.
         if (effectiveZoom != ancestor->style()->effectiveZoom())
             break;
     }
 
-    return node && node->isElementNode() ? toElement(node) : 0;
+    return node && node->isElementNode() ? toElement(node) : nullptr;
 }
 
 PositionWithAffinity LayoutObject::createPositionWithAffinity(int offset, EAffinity affinity)
 {
     // If this is a non-anonymous layoutObject in an editable area, then it's simple.
     if (Node* node = nonPseudoNode()) {
         if (!node->hasEditableStyle()) {
             // If it can be found, we prefer a visually equivalent position that is editable.
             Position position = createLegacyEditingPosition(node, offset);
             Position candidate = position.downstream(CanCrossEditingBoundary);
@@ skipping 302 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif