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

Source/core/layout/TextAutosizer.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 103 matching lines @@
             explanation.utf8().data(), pageInfo.utf8().data())));
 }
 #endif
 
 static const LayoutObject* parentElementLayoutObject(const LayoutObject* layoutObject)
 {
     // At style recalc, the layoutObject's parent may not be attached,
     // so we need to obtain this from the DOM tree.
     const Node* node = layoutObject->node();
     if (!node)
-        return 0;
+        return nullptr;
 
     // FIXME: This should be using LayoutTreeBuilderTraversal::parent().
     if (Element* parent = node->parentElement())
         return parent->layoutObject();
-    return 0;
+    return nullptr;
 }
 
 static bool isNonTextAreaFormControl(const LayoutObject* layoutObject)
 {
-    const Node* node = layoutObject ? layoutObject->node() : 0;
+    const Node* node = layoutObject ? layoutObject->node() : nullptr;
     if (!node || !node->isElementNode())
         return false;
     const Element* element = toElement(node);
 
     return (element->isFormControlElement() && !isHTMLTextAreaElement(element));
 }
 
 static bool isPotentialClusterRoot(const LayoutObject* layoutObject)
 {
     // "Potential cluster roots" are the smallest unit for which we can
@@ skipping 126 matching lines @@
 
 static bool hasExplicitWidth(const LayoutBlock* block)
 {
     // FIXME: This heuristic may need to be expanded to other ways a block can be wider or narrower
     //        than its parent containing block.
     return block->style() && block->style()->width().isSpecified();
 }
 
 TextAutosizer::TextAutosizer(const Document* document)
     : m_document(document)
-    , m_firstBlockToBeginLayout(0)
+    , m_firstBlockToBeginLayout(nullptr)
 #if ENABLE(ASSERT)
     , m_blocksThatHaveBegunLayout()
 #endif
     , m_superclusters()
     , m_clusterStack()
     , m_fingerprintMapper()
     , m_pageInfo()
     , m_updatePageInfoDeferred(false)
 {
 }
@@ skipping 124 matching lines @@
     } else if (!m_clusterStack.isEmpty() && currentCluster()->m_root == block) {
         m_clusterStack.removeLast();
     }
 }
 
 float TextAutosizer::inflate(LayoutObject* parent, InflateBehavior behavior, float multiplier)
 {
     Cluster* cluster = currentCluster();
     bool hasTextChild = false;
 
-    LayoutObject* child = 0;
+    LayoutObject* child = nullptr;
     if (parent->isLayoutBlock() && (parent->childrenInline() || behavior == DescendToInnerBlocks))
         child = toLayoutBlock(parent)->firstChild();
     else if (parent->isLayoutInline())
         child = toLayoutInline(parent)->firstChild();
 
     while (child) {
         if (child->isText()) {
             hasTextChild = true;
             // We only calculate this multiplier on-demand to ensure the parent block of this text
             // has entered layout.
@@ skipping 167 matching lines @@
             flags |= EXPLICIT_WIDTH;
 
         if ((mask & SUPPRESSING) && blockSuppressesAutosizing(block))
             flags |= SUPPRESSING;
     }
     return flags;
 }
 
 bool TextAutosizer::clusterWouldHaveEnoughTextToAutosize(const LayoutBlock* root, const LayoutBlock* widthProvider)
 {
-    Cluster hypotheticalCluster(root, classifyBlock(root), 0);
+    Cluster hypotheticalCluster(root, classifyBlock(root), nullptr);
     return clusterHasEnoughTextToAutosize(&hypotheticalCluster, widthProvider);
 }
 
 bool TextAutosizer::clusterHasEnoughTextToAutosize(Cluster* cluster, const LayoutBlock* widthProvider)
 {
     if (cluster->m_hasEnoughTextToAutosize != UnknownAmountOfText)
         return cluster->m_hasEnoughTextToAutosize == HasEnoughText;
 
     const LayoutBlock* root = cluster->m_root;
     if (!widthProvider)
@@ skipping 82 matching lines @@
 
     return StringHasher::computeHash<UChar>(
         static_cast<const UChar*>(static_cast<const void*>(&data)),
         sizeof data / sizeof(UChar));
 }
 
 TextAutosizer::Cluster* TextAutosizer::maybeCreateCluster(const LayoutBlock* block)
 {
     BlockFlags flags = classifyBlock(block);
     if (!(flags & POTENTIAL_ROOT))
-        return 0;
+        return nullptr;
 
-    Cluster* parentCluster = m_clusterStack.isEmpty() ? 0 : currentCluster();
+    Cluster* parentCluster = m_clusterStack.isEmpty() ? nullptr : currentCluster();
     ASSERT(parentCluster || block->isLayoutView());
 
     // If a non-independent block would not alter the SUPPRESSING flag, it doesn't need to be a cluster.
     bool parentSuppresses = parentCluster && (parentCluster->m_flags & SUPPRESSING);
     if (!(flags & INDEPENDENT) && !(flags & EXPLICIT_WIDTH) && !!(flags & SUPPRESSING) == parentSuppresses)
-        return 0;
+        return nullptr;
 
     Cluster* cluster = new Cluster(block, flags, parentCluster, getSupercluster(block));
 #ifdef AUTOSIZING_DOM_DEBUG_INFO
     // Non-SUPPRESSING clusters are annotated in clusterMultiplier.
     if (flags & SUPPRESSING)
         writeClusterDebugInfo(cluster);
 #endif
     return cluster;
 }
 
 TextAutosizer::Supercluster* TextAutosizer::getSupercluster(const LayoutBlock* block)
 {
     Fingerprint fingerprint = m_fingerprintMapper.get(block);
     if (!fingerprint)
-        return 0;
+        return nullptr;
 
     BlockSet* roots = m_fingerprintMapper.getTentativeClusterRoots(fingerprint);
     if (!roots || roots->size() < 2 || !roots->contains(block))
-        return 0;
+        return nullptr;
 
     SuperclusterMap::AddResult addResult = m_superclusters.add(fingerprint, PassOwnPtr<Supercluster>());
     if (!addResult.isNewEntry)
         return addResult.storedValue->value.get();
 
     Supercluster* supercluster = new Supercluster(roots);
     addResult.storedValue->value = adoptPtr(supercluster);
     return supercluster;
 }
 
@@ skipping 195 matching lines @@
         // Note: At this point clusters may not have been created for these blocks so we cannot rely
         //       on m_clusters. Instead, we use a best-guess about whether the block will become a cluster.
         if (!classifyBlock(child, INDEPENDENT)) {
             if (const LayoutObject* leaf = findTextLeaf(child, depth, firstOrLast))
                 return leaf;
         }
         child = (firstOrLast == First) ? child->nextSibling() : child->previousSibling();
     }
     --depth;
 
-    return 0;
+    return nullptr;
 }
 
 void TextAutosizer::applyMultiplier(LayoutObject* layoutObject, float multiplier, RelayoutBehavior relayoutBehavior)
 {
     ASSERT(layoutObject);
     ComputedStyle& currentStyle = layoutObject->mutableStyleRef();
     if (currentStyle.textAutosizingMultiplier() == multiplier)
         return;
 
     // We need to clone the layoutObject style to avoid breaking style sharing.
@@ skipping 197 matching lines @@
     }
     return computedSize;
 }
 
 DEFINE_TRACE(TextAutosizer)
 {
     visitor->trace(m_document);
 }
 
 } // namespace blink