Allow assertions to be enabled in Blink Release builds.

Source/core/rendering/FastTextAutosizer.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 261 matching lines @@
 static bool hasExplicitWidth(const RenderBlock* 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();
 }
 
 FastTextAutosizer::FastTextAutosizer(const Document* document)
     : m_document(document)
     , m_firstBlockToBeginLayout(0)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     , m_blocksThatHaveBegunLayout()
 #endif
     , m_superclusters()
     , m_clusterStack()
     , m_fingerprintMapper()
     , m_pageInfo()
     , m_updatePageInfoDeferred(false)
 {
 }
 
@@ skipping 23 matching lines @@
         // Clear the cluster stack and the supercluster map to avoid stale pointers.
         // Speculative fix for http://crbug.com/369485.
         m_firstBlockToBeginLayout = 0;
         m_clusterStack.clear();
         m_superclusters.clear();
     }
 }
 
 FastTextAutosizer::BeginLayoutBehavior FastTextAutosizer::prepareForLayout(const RenderBlock* block)
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     m_blocksThatHaveBegunLayout.add(block);
 #endif
 
     if (!m_firstBlockToBeginLayout) {
         m_firstBlockToBeginLayout = block;
         prepareClusterStack(block->parent());
     } else if (block == currentCluster()->m_root) {
         // Ignore beginLayout on the same block twice.
         // This can happen with paginated overflow.
         return StopLayout;
     }
 
     return ContinueLayout;
 }
 
 void FastTextAutosizer::prepareClusterStack(const RenderObject* renderer)
 {
     if (!renderer)
         return;
     prepareClusterStack(renderer->parent());
 
     if (renderer->isRenderBlock()) {
         const RenderBlock* block = toRenderBlock(renderer);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         m_blocksThatHaveBegunLayout.add(block);
 #endif
         if (Cluster* cluster = maybeCreateCluster(block))
             m_clusterStack.append(adoptPtr(cluster));
     }
 }
 
 void FastTextAutosizer::beginLayout(RenderBlock* block)
 {
     ASSERT(shouldHandleLayout());
@@ skipping 58 matching lines @@
 
 void FastTextAutosizer::endLayout(RenderBlock* block)
 {
     ASSERT(shouldHandleLayout());
 
     if (block == m_firstBlockToBeginLayout) {
         m_firstBlockToBeginLayout = 0;
         m_clusterStack.clear();
         m_superclusters.clear();
         m_stylesRetainedDuringLayout.clear();
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         m_blocksThatHaveBegunLayout.clear();
 #endif
     // Tables can create two layout scopes for the same block so the isEmpty
     // check below is needed to guard against endLayout being called twice.
     } else if (!m_clusterStack.isEmpty() && currentCluster()->m_root == block) {
         m_clusterStack.removeLast();
     }
 }
 
 float FastTextAutosizer::inflate(RenderObject* parent, InflateBehavior behavior, float multiplier)
@@ skipping 562 matching lines @@
 
     return false;
 }
 
 FastTextAutosizer::Cluster* FastTextAutosizer::currentCluster() const
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!m_clusterStack.isEmpty());
     return m_clusterStack.last().get();
 }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 void FastTextAutosizer::FingerprintMapper::assertMapsAreConsistent()
 {
     // For each fingerprint -> block mapping in m_blocksForFingerprint we should have an associated
     // map from block -> fingerprint in m_fingerprints.
     ReverseFingerprintMap::iterator end = m_blocksForFingerprint.end();
     for (ReverseFingerprintMap::iterator fingerprintIt = m_blocksForFingerprint.begin(); fingerprintIt != end; ++fingerprintIt) {
         Fingerprint fingerprint = fingerprintIt->key;
         BlockSet* blocks = fingerprintIt->value.get();
         for (BlockSet::iterator blockIt = blocks->begin(); blockIt != blocks->end(); ++blockIt) {
             const RenderBlock* block = (*blockIt);
             ASSERT(m_fingerprints.get(block) == fingerprint);
         }
     }
 }
 #endif
 
 void FastTextAutosizer::FingerprintMapper::add(const RenderObject* renderer, Fingerprint fingerprint)
 {
     remove(renderer);
 
     m_fingerprints.set(renderer, fingerprint);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     assertMapsAreConsistent();
 #endif
 }
 
 void FastTextAutosizer::FingerprintMapper::addTentativeClusterRoot(const RenderBlock* block, Fingerprint fingerprint)
 {
     add(block, fingerprint);
 
     ReverseFingerprintMap::AddResult addResult = m_blocksForFingerprint.add(fingerprint, PassOwnPtr<BlockSet>());
     if (addResult.isNewEntry)
         addResult.storedValue->value = adoptPtr(new BlockSet);
     addResult.storedValue->value->add(block);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     assertMapsAreConsistent();
 #endif
 }
 
 bool FastTextAutosizer::FingerprintMapper::remove(const RenderObject* renderer)
 {
     Fingerprint fingerprint = m_fingerprints.take(renderer);
     if (!fingerprint || !renderer->isRenderBlock())
         return false;
 
     ReverseFingerprintMap::iterator blocksIter = m_blocksForFingerprint.find(fingerprint);
     if (blocksIter == m_blocksForFingerprint.end())
         return false;
 
     BlockSet& blocks = *blocksIter->value;
     blocks.remove(toRenderBlock(renderer));
     if (blocks.isEmpty())
         m_blocksForFingerprint.remove(blocksIter);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     assertMapsAreConsistent();
 #endif
     return true;
 }
 
 FastTextAutosizer::Fingerprint FastTextAutosizer::FingerprintMapper::get(const RenderObject* renderer)
 {
     return m_fingerprints.get(renderer);
 }
 
@@ skipping 71 matching lines @@
         computedSize = multiplier * specifiedSize;
     } else {
         computedSize = multiplier * pleasantSize + gradientAfterPleasantSize * (specifiedSize - pleasantSize);
         if (computedSize < specifiedSize)
             computedSize = specifiedSize;
     }
     return computedSize;
 }
 
 } // namespace WebCore