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

Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 60 matching lines @@
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // Used by flexible boxes when flexing this element and by table cells.
 typedef WTF::HashMap<const LayoutBox*, LayoutUnit> OverrideSizeMap;
 
 // Used by grid elements to properly size their grid items.
 // FIXME: Move these into LayoutBoxRareData.
-static OverrideSizeMap* gOverrideContainingBlockLogicalHeightMap = 0;
-static OverrideSizeMap* gOverrideContainingBlockLogicalWidthMap = 0;
-static OverrideSizeMap* gExtraInlineOffsetMap = 0;
-static OverrideSizeMap* gExtraBlockOffsetMap = 0;
+static OverrideSizeMap* gOverrideContainingBlockLogicalHeightMap = nullptr;
+static OverrideSizeMap* gOverrideContainingBlockLogicalWidthMap = nullptr;
+static OverrideSizeMap* gExtraInlineOffsetMap = nullptr;
+static OverrideSizeMap* gExtraBlockOffsetMap = nullptr;
 
 
 // Size of border belt for autoscroll. When mouse pointer in border belt,
 // autoscroll is started.
 static const int autoscrollBeltSize = 20;
 static const unsigned backgroundObscurationTestMaxDepth = 4;
 
 static bool skipBodyBackground(const LayoutBox* bodyElementLayoutObject)
 {
     ASSERT(bodyElementLayoutObject->isBody());
@@ skipping 52 matching lines @@
 }
 
 void LayoutBox::removeFloatingOrPositionedChildFromBlockLists()
 {
     ASSERT(isFloatingOrOutOfFlowPositioned());
 
     if (documentBeingDestroyed())
         return;
 
     if (isFloating()) {
-        LayoutBlockFlow* parentBlockFlow = 0;
+        LayoutBlockFlow* parentBlockFlow = nullptr;
         for (LayoutObject* curr = parent(); curr && !curr->isLayoutView(); curr = curr->parent()) {
             if (curr->isLayoutBlockFlow()) {
                 LayoutBlockFlow* currBlockFlow = toLayoutBlockFlow(curr);
                 if (!parentBlockFlow || currBlockFlow->containsFloat(this))
                     parentBlockFlow = currBlockFlow;
             }
         }
 
         if (parentBlockFlow) {
             parentBlockFlow->markSiblingsWithFloatsForLayout(this);
@@ skipping 303 matching lines @@
         }
     }
     return false;
 }
 
 void LayoutBox::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     // Presumably the same issue as in setScrollTop. See crbug.com/343132.
     DisableCompositingQueryAsserts disabler;
 
-    LayoutBox* parentBox = 0;
+    LayoutBox* parentBox = nullptr;
     LayoutRect newRect = rect;
 
     bool restrictedByLineClamp = false;
     if (parent()) {
         parentBox = parent()->enclosingBox();
         restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
     }
 
     if (hasOverflowClip() && !restrictedByLineClamp) {
         // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
         // This will prevent us from revealing text hidden by the slider in Safari RSS.
         newRect = layer()->scrollableArea()->scrollIntoView(rect, alignX, alignY);
     } else if (!parentBox && canBeProgramaticallyScrolled()) {
         if (FrameView* frameView = this->frameView()) {
             HTMLFrameOwnerElement* ownerElement = document().ownerElement();
             if (!isDisallowedAutoscroll(ownerElement, frameView)) {
                 frameView->scrollableArea()->scrollIntoView(rect, alignX, alignY);
 
                 if (ownerElement && ownerElement->layoutObject()) {
                     if (frameView->safeToPropagateScrollToParent()) {
                         parentBox = ownerElement->layoutObject()->enclosingBox();
                         // FIXME: This doesn't correctly convert the rect to
                         // absolute coordinates in the parent.
                         newRect.setX(rect.x() - frameView->scrollX() + frameView->x());
                         newRect.setY(rect.y() - frameView->scrollY() + frameView->y());
                     } else {
-                        parentBox = 0;
+                        parentBox = nullptr;
                     }
                 }
             }
         }
     }
 
     // If we are fixed-position, it is useless to scroll the parent.
     if (hasLayer() && layer()->scrollsWithViewport())
         return;
 
@@ skipping 1171 matching lines @@
 {
     return new InlineBox(*this);
 }
 
 void LayoutBox::dirtyLineBoxes(bool fullLayout)
 {
     if (inlineBoxWrapper()) {
         if (fullLayout) {
             inlineBoxWrapper()->destroy();
             ASSERT(m_rareData);
-            m_rareData->m_inlineBoxWrapper = 0;
+            m_rareData->m_inlineBoxWrapper = nullptr;
         } else {
             inlineBoxWrapper()->dirtyLineBoxes();
         }
     }
 }
 
 void LayoutBox::positionLineBox(InlineBox* box)
 {
     if (isOutOfFlowPositioned()) {
         // Cache the x position only if we were an INLINE type originally.
@@ skipping 37 matching lines @@
         setChildNeedsLayout(MarkOnlyThis);
 }
 
 void LayoutBox::deleteLineBoxWrapper()
 {
     if (inlineBoxWrapper()) {
         if (!documentBeingDestroyed())
             inlineBoxWrapper()->remove();
         inlineBoxWrapper()->destroy();
         ASSERT(m_rareData);
-        m_rareData->m_inlineBoxWrapper = 0;
+        m_rareData->m_inlineBoxWrapper = nullptr;
     }
 }
 
 void LayoutBox::setSpannerPlaceholder(LayoutMultiColumnSpannerPlaceholder& placeholder)
 {
     RELEASE_ASSERT(!m_rareData || !m_rareData->m_spannerPlaceholder); // not expected to change directly from one spanner to another.
     ensureRareData().m_spannerPlaceholder = &placeholder;
 }
 
 void LayoutBox::clearSpannerPlaceholder()
 {
     if (!m_rareData)
         return;
-    m_rareData->m_spannerPlaceholder = 0;
+    m_rareData->m_spannerPlaceholder = nullptr;
 }
 
 LayoutRect LayoutBox::clippedOverflowRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     if (style()->visibility() != VISIBLE) {
         DeprecatedPaintLayer* layer = enclosingLayer();
         layer->updateDescendantDependentFlags();
         if (layer->subtreeIsInvisible())
             return LayoutRect();
     }
@@ skipping 2051 matching lines @@
 
         if (point.x() < 0 || point.x() > right || point.y() < 0 || point.y() > bottom) {
             if (point.x() <= right / 2)
                 return createPositionWithAffinity(firstPositionInOrBeforeNode(nonPseudoNode()));
             return createPositionWithAffinity(lastPositionInOrAfterNode(nonPseudoNode()));
         }
     }
 
     // Pass off to the closest child.
     LayoutUnit minDist = LayoutUnit::max();
-    LayoutBox* closestLayoutObject = 0;
+    LayoutBox* closestLayoutObject = nullptr;
     LayoutPoint adjustedPoint = point;
     if (isTableRow())
         adjustedPoint.moveBy(location());
 
     for (LayoutObject* layoutObject = firstChild; layoutObject; layoutObject = layoutObject->nextSibling()) {
         if ((!layoutObject->slowFirstChild() && !layoutObject->isInline() && !layoutObject->isLayoutBlockFlow() )
             || layoutObject->style()->visibility() != VISIBLE)
             continue;
 
         if (!layoutObject->isBox())
@@ skipping 537 matching lines @@
 
 DeprecatedPaintLayer* LayoutBox::enclosingFloatPaintingLayer() const
 {
     const LayoutObject* curr = this;
     while (curr) {
         DeprecatedPaintLayer* layer = curr->hasLayer() && curr->isBox() ? toLayoutBox(curr)->layer() : 0;
         if (layer && layer->isSelfPaintingLayer())
             return layer;
         curr = curr->parent();
     }
-    return 0;
+    return nullptr;
 }
 
 LayoutRect LayoutBox::logicalVisualOverflowRectForPropagation(const ComputedStyle& parentStyle) const
 {
     LayoutRect rect = visualOverflowRectForPropagation(parentStyle);
     if (!parentStyle.isHorizontalWritingMode())
         return rect.transposedRect();
     return rect;
 }
 
@@ skipping 380 matching lines @@
 bool LayoutBox::canRenderBorderImage() const
 {
     if (!style()->hasBorderDecoration())
         return false;
 
     StyleImage* borderImage = style()->borderImage().image();
     return borderImage && borderImage->canRender(*this, style()->effectiveZoom()) && borderImage->isLoaded();
 }
 
 } // namespace blink