Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/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 86 matching lines @@
       !layoutObject->style()->isDisplayReplacedType())
     return false;
   if (layoutObject->isListItem())
     return (layoutObject->isFloating() ||
             layoutObject->isOutOfFlowPositioned());
 
   return true;
 }
 
 static bool isIndependentDescendant(const LayoutBlock* layoutObject) {
-  ASSERT(isPotentialClusterRoot(layoutObject));
+  DCHECK(isPotentialClusterRoot(layoutObject));
 
   LayoutBlock* containingBlock = layoutObject->containingBlock();
   return layoutObject->isLayoutView() || layoutObject->isFloating() ||
          layoutObject->isOutOfFlowPositioned() || layoutObject->isTableCell() ||
          layoutObject->isTableCaption() ||
          layoutObject->isFlexibleBoxIncludingDeprecated() ||
          (containingBlock &&
           containingBlock->isHorizontalWritingMode() !=
               layoutObject->isHorizontalWritingMode()) ||
          layoutObject->style()->isDisplayReplacedType() ||
@@ skipping 119 matching lines @@
       m_pageInfo(),
       m_updatePageInfoDeferred(false) {
 }
 
 TextAutosizer::~TextAutosizer() {}
 
 void TextAutosizer::record(LayoutBlock* block) {
   if (!m_pageInfo.m_settingEnabled)
     return;
 
-  ASSERT(!m_blocksThatHaveBegunLayout.contains(block));
+#if DCHECK_IS_ON()
+  DCHECK(!m_blocksThatHaveBegunLayout.contains(block));
+#endif
   if (!classifyBlock(block, INDEPENDENT | EXPLICIT_WIDTH)) {
     // !everHadLayout() means the object hasn't layout yet
     // which means this object is new added.
     // We only deal with new added block here.
     // If parent is new added, no need to check its children.
     LayoutObject* parent = getParent(block);
     if (!block->everHadLayout() && parent && parent->everHadLayout())
       markSuperclusterForConsistencyCheck(parent);
     return;
   }
@@ skipping 10 matching lines @@
     return;
   LayoutObject* parent = getParent(text);
   if (parent && parent->everHadLayout())
     markSuperclusterForConsistencyCheck(parent);
 }
 
 void TextAutosizer::destroy(LayoutBlock* block) {
   if (!m_pageInfo.m_settingEnabled && !m_fingerprintMapper.hasFingerprints())
     return;
 
-  ASSERT(!m_blocksThatHaveBegunLayout.contains(block));
+#if DCHECK_IS_ON()
+  DCHECK(!m_blocksThatHaveBegunLayout.contains(block));
+#endif
 
   if (m_fingerprintMapper.remove(block) && m_firstBlockToBeginLayout) {
     // LayoutBlock with a fingerprint was destroyed during layout.
     // Clear the cluster stack and the supercluster map to avoid stale pointers.
     // Speculative fix for http://crbug.com/369485.
     m_firstBlockToBeginLayout = nullptr;
     m_clusterStack.clear();
   }
 }
 
@@ skipping 27 matching lines @@
 #if DCHECK_IS_ON()
     m_blocksThatHaveBegunLayout.insert(block);
 #endif
     if (Cluster* cluster = maybeCreateCluster(block))
       m_clusterStack.push_back(WTF::wrapUnique(cluster));
   }
 }
 
 void TextAutosizer::beginLayout(LayoutBlock* block,
                                 SubtreeLayoutScope* layouter) {
-  ASSERT(shouldHandleLayout());
+  DCHECK(shouldHandleLayout());
 
   if (prepareForLayout(block) == StopLayout)
     return;
 
   // Skip ruby's inner blocks, because these blocks already are inflated.
   if (block->isRubyRun() || block->isRubyBase() || block->isRubyText())
     return;
 
-  ASSERT(!m_clusterStack.isEmpty() || block->isLayoutView());
+  DCHECK(!m_clusterStack.isEmpty() || block->isLayoutView());
 
   if (Cluster* cluster = maybeCreateCluster(block))
     m_clusterStack.push_back(WTF::wrapUnique(cluster));
 
-  ASSERT(!m_clusterStack.isEmpty());
+  DCHECK(!m_clusterStack.isEmpty());
 
   // Cells in auto-layout tables are handled separately by inflateAutoTable.
   bool isAutoTableCell =
       block->isTableCell() &&
       !toLayoutTableCell(block)->table()->style()->isFixedTableLayout();
   if (!isAutoTableCell && !m_clusterStack.isEmpty())
     inflate(block, layouter);
 }
 
 void TextAutosizer::inflateAutoTable(LayoutTable* table) {
-  ASSERT(table);
-  ASSERT(!table->style()->isFixedTableLayout());
-  ASSERT(table->containingBlock());
+  DCHECK(table);
+  DCHECK(!table->style()->isFixedTableLayout());
+  DCHECK(table->containingBlock());
 
   Cluster* cluster = currentCluster();
   if (cluster->m_root != table)
     return;
 
   // Pre-inflate cells that have enough text so that their inflated preferred
   // widths will be used for column sizing.
   for (LayoutObject* section = table->firstChild(); section;
        section = section->nextSibling()) {
     if (!section->isTableSection())
       continue;
     for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row;
          row = row->nextRow()) {
       for (LayoutTableCell* cell = row->firstCell(); cell;
            cell = cell->nextCell()) {
         if (!cell->needsLayout())
           continue;
 
         beginLayout(cell, nullptr);
         inflate(cell, nullptr, DescendToInnerBlocks);
         endLayout(cell);
       }
     }
   }
 }
 
 void TextAutosizer::endLayout(LayoutBlock* block) {
-  ASSERT(shouldHandleLayout());
+  DCHECK(shouldHandleLayout());
 
   if (block == m_firstBlockToBeginLayout) {
     m_firstBlockToBeginLayout = nullptr;
     m_clusterStack.clear();
     m_stylesRetainedDuringLayout.clear();
 #if DCHECK_IS_ON()
     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.
@@ skipping 125 matching lines @@
   }
 
   // If we didn't add any supercluster, we should add one.
   if (lastSupercluster) {
     m_fingerprintMapper.getPotentiallyInconsistentSuperclusters().insert(
         lastSupercluster);
   }
 }
 
 void TextAutosizer::updatePageInfoInAllFrames() {
-  ASSERT(!m_document->frame() || m_document->frame()->isMainFrame());
+  DCHECK(!m_document->frame() || m_document->frame()->isMainFrame());
 
   for (Frame* frame = m_document->frame(); frame;
        frame = frame->tree().traverseNext()) {
     if (!frame->isLocalFrame())
       continue;
 
     Document* document = toLocalFrame(frame)->document();
     // If document is being detached, skip updatePageInfo.
     if (!document || !document->isActive())
       continue;
@@ skipping 76 matching lines @@
   } else if (previousPageInfo.m_hasAutosized) {
     // If we are no longer autosizing the page, we won't do anything during the
     // next layout. Set all the multipliers back to 1 now.
     resetMultipliers();
     m_pageInfo.m_hasAutosized = false;
   }
 }
 
 IntSize TextAutosizer::windowSize() const {
   Page* page = m_document->page();
-  ASSERT(page);
+  DCHECK(page);
   return page->visualViewport().size();
 }
 
 void TextAutosizer::resetMultipliers() {
   LayoutObject* layoutObject =
       LayoutAPIShim::layoutObjectFrom(m_document->layoutViewItem());
   while (layoutObject) {
     if (const ComputedStyle* style = layoutObject->style()) {
       if (style->textAutosizingMultiplier() != 1)
         applyMultiplier(layoutObject, 1, nullptr, LayoutNeeded);
@@ skipping 157 matching lines @@
       sizeof data / sizeof(UChar));
 }
 
 TextAutosizer::Cluster* TextAutosizer::maybeCreateCluster(LayoutBlock* block) {
   BlockFlags flags = classifyBlock(block);
   if (!(flags & POTENTIAL_ROOT))
     return nullptr;
 
   Cluster* parentCluster =
       m_clusterStack.isEmpty() ? nullptr : currentCluster();
-  ASSERT(parentCluster || block->isLayoutView());
+  DCHECK(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 nullptr;
 
   bool isNewEntry = false;
@@ skipping 43 matching lines @@
           multiplierFromBlock(clusterWidthProvider(cluster->m_root));
     else
       cluster->m_multiplier = 1.0f;
   } else {
     cluster->m_multiplier =
         cluster->m_parent ? clusterMultiplier(cluster->m_parent) : 1.0f;
     if (cluster->m_supercluster)
       cluster->m_supercluster->m_inheritParentMultiplier = InheritMultiplier;
   }
 
-  ASSERT(cluster->m_multiplier);
+  DCHECK(cluster->m_multiplier);
   return cluster->m_multiplier;
 }
 
 bool TextAutosizer::superclusterHasEnoughTextToAutosize(
     Supercluster* supercluster,
     const LayoutBlock* widthProvider,
     const bool skipLayoutedNodes) {
   if (supercluster->m_hasEnoughTextToAutosize != UnknownAmountOfText)
     return supercluster->m_hasEnoughTextToAutosize == HasEnoughText;
 
@@ skipping 13 matching lines @@
   Supercluster* supercluster = cluster->m_supercluster;
   if (!supercluster->m_multiplier) {
     const LayoutBlock* widthProvider =
         maxClusterWidthProvider(cluster->m_supercluster, cluster->m_root);
     CHECK(widthProvider);
     supercluster->m_multiplier =
         superclusterHasEnoughTextToAutosize(supercluster, widthProvider, false)
             ? multiplierFromBlock(widthProvider)
             : 1.0f;
   }
-  ASSERT(supercluster->m_multiplier);
+  DCHECK(supercluster->m_multiplier);
   return supercluster->m_multiplier;
 }
 
 const LayoutBlock* TextAutosizer::clusterWidthProvider(
     const LayoutBlock* root) const {
   if (root->isTable() || root->isTableCell())
     return root;
 
   return deepestBlockContainingAllText(root);
 }
@@ skipping 56 matching lines @@
       return width;
   }
   return 0;
 }
 
 float TextAutosizer::multiplierFromBlock(const LayoutBlock* block) {
   // If block->needsLayout() is false, it does not need to be in
   // m_blocksThatHaveBegunLayout. This can happen during layout of a positioned
   // object if the cluster's DBCAT is deeper than the positioned object's
   // containing block, and wasn't marked as needing layout.
-  ASSERT(m_blocksThatHaveBegunLayout.contains(block) || !block->needsLayout());
-
+#if DCHECK_IS_ON()
+  DCHECK(m_blocksThatHaveBegunLayout.contains(block) || !block->needsLayout());
+#endif
   // Block width, in CSS pixels.
   float blockWidth = widthFromBlock(block);
   float layoutWidth =
       std::min(blockWidth, static_cast<float>(m_pageInfo.m_layoutWidth));
   float multiplier =
       m_pageInfo.m_frameWidth ? layoutWidth / m_pageInfo.m_frameWidth : 1.0f;
   multiplier *= m_pageInfo.m_accessibilityFontScaleFactor *
                 m_pageInfo.m_deviceScaleAdjustment;
   return std::max(multiplier, 1.0f);
 }
@@ skipping 10 matching lines @@
 // FIXME: Refactor this to look more like TextAutosizer::deepestCommonAncestor.
 const LayoutBlock* TextAutosizer::deepestBlockContainingAllText(
     const LayoutBlock* root) const {
   size_t firstDepth = 0;
   const LayoutObject* firstTextLeaf = findTextLeaf(root, firstDepth, First);
   if (!firstTextLeaf)
     return root;
 
   size_t lastDepth = 0;
   const LayoutObject* lastTextLeaf = findTextLeaf(root, lastDepth, Last);
-  ASSERT(lastTextLeaf);
+  DCHECK(lastTextLeaf);
 
   // Equalize the depths if necessary. Only one of the while loops below will
   // get executed.
   const LayoutObject* firstNode = firstTextLeaf;
   const LayoutObject* lastNode = lastTextLeaf;
   while (firstDepth > lastDepth) {
     firstNode = firstNode->parent();
     --firstDepth;
   }
   while (lastDepth > firstDepth) {
@@ skipping 13 matching lines @@
 
   // containingBlock() should never leave the cluster, since it only skips
   // ancestors when finding the container of position:absolute/fixed blocks, and
   // those cannot exist between a cluster and its text node's lowest common
   // ancestor as isAutosizingCluster would have made them into their own
   // independent cluster.
   const LayoutBlock* containingBlock = firstNode->containingBlock();
   if (!containingBlock)
     return root;
 
-  ASSERT(containingBlock->isDescendantOf(root));
+  DCHECK(containingBlock->isDescendantOf(root));
   return containingBlock;
 }
 
 const LayoutObject* TextAutosizer::findTextLeaf(
     const LayoutObject* parent,
     size_t& depth,
     TextLeafSearch firstOrLast) const {
   // List items are treated as text due to the marker.
   if (parent->isListItem())
     return parent;
@@ skipping 17 matching lines @@
   }
   --depth;
 
   return nullptr;
 }
 
 void TextAutosizer::applyMultiplier(LayoutObject* layoutObject,
                                     float multiplier,
                                     SubtreeLayoutScope* layouter,
                                     RelayoutBehavior relayoutBehavior) {
-  ASSERT(layoutObject);
+  DCHECK(layoutObject);
   ComputedStyle& currentStyle = layoutObject->mutableStyleRef();
   if (!currentStyle.getTextSizeAdjust().isAuto()) {
     // The accessibility font scale factor is applied by the autosizer so we
     // need to apply that scale factor on top of the text-size-adjust
     // multiplier. Only apply the accessibility factor if the autosizer has
     // determined a multiplier should be applied so that text-size-adjust:none
     // does not cause a multiplier to be applied when it wouldn't be otherwise.
     bool shouldApplyAccessibilityFontScaleFactor = multiplier > 1;
     multiplier = currentStyle.getTextSizeAdjust().multiplier();
     if (shouldApplyAccessibilityFontScaleFactor)
@@ skipping 39 matching lines @@
   layoutObject->clearBaseComputedStyle();
 }
 
 bool TextAutosizer::isWiderOrNarrowerDescendant(Cluster* cluster) {
   // FIXME: Why do we return true when hasExplicitWidth returns false??
   if (!cluster->m_parent || !hasExplicitWidth(cluster->m_root))
     return true;
 
   const LayoutBlock* parentDeepestBlockContainingAllText =
       deepestBlockContainingAllText(cluster->m_parent);
-  ASSERT(m_blocksThatHaveBegunLayout.contains(cluster->m_root));
-  ASSERT(m_blocksThatHaveBegunLayout.contains(
+#if DCHECK_IS_ON()
+  DCHECK(m_blocksThatHaveBegunLayout.contains(cluster->m_root));
+  DCHECK(m_blocksThatHaveBegunLayout.contains(
       parentDeepestBlockContainingAllText));
+#endif
 
   float contentWidth = cluster->m_root->contentLogicalWidth().toFloat();
   float clusterTextWidth =
       parentDeepestBlockContainingAllText->contentLogicalWidth().toFloat();
 
   // Clusters with a root that is wider than the deepestBlockContainingAllText
   // of their parent autosize independently of their parent.
   if (contentWidth > clusterTextWidth)
     return true;
 
@@ skipping 32 matching lines @@
   // 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 LayoutBlock* block = (*blockIt);
-      ASSERT(m_fingerprints.at(block) == fingerprint);
+      DCHECK_EQ(m_fingerprints.at(block), fingerprint);
     }
   }
 }
 #endif
 
 void TextAutosizer::FingerprintMapper::add(LayoutObject* layoutObject,
                                            Fingerprint fingerprint) {
   remove(layoutObject);
 
   m_fingerprints.set(layoutObject, fingerprint);
@@ skipping 71 matching lines @@
 }
 
 TextAutosizer::LayoutScope::~LayoutScope() {
   if (m_textAutosizer)
     m_textAutosizer->endLayout(m_block);
 }
 
 TextAutosizer::TableLayoutScope::TableLayoutScope(LayoutTable* table)
     : LayoutScope(table) {
   if (m_textAutosizer) {
-    ASSERT(m_textAutosizer->shouldHandleLayout());
+    DCHECK(m_textAutosizer->shouldHandleLayout());
     m_textAutosizer->inflateAutoTable(table);
   }
 }
 
 TextAutosizer::DeferUpdatePageInfo::DeferUpdatePageInfo(Page* page)
     : m_mainFrame(page->deprecatedLocalMainFrame()) {
   if (TextAutosizer* textAutosizer = m_mainFrame->document()->textAutosizer()) {
-    ASSERT(!textAutosizer->m_updatePageInfoDeferred);
+    DCHECK(!textAutosizer->m_updatePageInfoDeferred);
     textAutosizer->m_updatePageInfoDeferred = true;
   }
 }
 
 TextAutosizer::DeferUpdatePageInfo::~DeferUpdatePageInfo() {
   if (TextAutosizer* textAutosizer = m_mainFrame->document()->textAutosizer()) {
-    ASSERT(textAutosizer->m_updatePageInfoDeferred);
+    DCHECK(textAutosizer->m_updatePageInfoDeferred);
     textAutosizer->m_updatePageInfoDeferred = false;
     textAutosizer->updatePageInfoInAllFrames();
   }
 }
 
 float TextAutosizer::computeAutosizedFontSize(float specifiedSize,
                                               float multiplier) {
   DCHECK_GE(multiplier, 0);
 
   // Somewhat arbitrary "pleasant" font size.
@@ skipping 57 matching lines @@
     }
   }
   potentiallyInconsistentSuperclusters.clear();
 }
 
 DEFINE_TRACE(TextAutosizer) {
   visitor->trace(m_document);
 }
 
 }  // namespace blink