Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 70 matching lines @@
 
     // If this box has a transform, it acts as a fixed position container
     // for fixed descendants, which prevents the propagation of 'fixed'
     // unless the layer itself is also fixed position.
     if (i && currentStep.m_flags & ContainsFixedPosition &&
         !(currentStep.m_flags & IsFixedPosition))
       inFixed = false;
     else if (currentStep.m_flags & IsFixedPosition)
       inFixed = true;
 
-    ASSERT(!i == isTopmostLayoutView(currentStep.m_layoutObject));
+#if DCHECK_IS_ON()
+    DCHECK_EQ(!i, isTopmostLayoutView(currentStep.m_layoutObject));
+#endif
 
     if (!i) {
       // A null container indicates mapping through the root LayoutView, so
       // including its transform (the page scale).
       if (!ancestor && currentStep.m_transform)
         transformState.applyTransform(*currentStep.m_transform.get());
     } else {
       TransformState::TransformAccumulation accumulate =
           currentStep.m_flags & AccumulatingTransform
               ? TransformState::AccumulateTransform
               : TransformState::FlattenTransform;
       if (currentStep.m_transform)
         transformState.applyTransform(*currentStep.m_transform.get(),
                                       accumulate);
       else
         transformState.move(currentStep.m_offset.width(),
                             currentStep.m_offset.height(), accumulate);
     }
 
     if (inFixed && !currentStep.m_offsetForFixedPosition.isZero()) {
-      ASSERT(currentStep.m_layoutObject->isLayoutView());
+      DCHECK(currentStep.m_layoutObject->isLayoutView());
       transformState.move(currentStep.m_offsetForFixedPosition);
     }
   }
 
-  ASSERT(foundAncestor);
+#if DCHECK_IS_ON()
+  DCHECK(foundAncestor);
+#endif
   transformState.flatten();
 }
 
 #ifndef NDEBUG
 // Handy function to call from gdb while debugging mismatched point/rect errors.
 void LayoutGeometryMap::dumpSteps() const {
   fprintf(stderr, "LayoutGeometryMap::dumpSteps accumulatedOffset=%d,%d\n",
           m_accumulatedOffset.width().toInt(),
           m_accumulatedOffset.height().toInt());
   for (int i = m_mapping.size() - 1; i >= 0; --i) {
@@ skipping 30 matching lines @@
     const LayoutObject* lastLayoutObject = m_mapping.back().m_layoutObject;
 
     FloatRect layoutObjectMappedResult =
         lastLayoutObject
             ->localToAncestorQuad(rect, ancestor, m_mapCoordinatesFlags)
             .boundingBox();
 
     // Inspector creates layoutObjects with negative width
     // <https://bugs.webkit.org/show_bug.cgi?id=87194>.
     // Taking FloatQuad bounds avoids spurious assertions because of that.
-    ASSERT(enclosingIntRect(layoutObjectMappedResult) ==
+    DCHECK(enclosingIntRect(layoutObjectMappedResult) ==
                enclosingIntRect(result.boundingBox()) ||
            layoutObjectMappedResult.mayNotHaveExactIntRectRepresentation() ||
            result.boundingBox().mayNotHaveExactIntRectRepresentation());
   }
 #endif
 
   return result;
 }
 
 void LayoutGeometryMap::pushMappingsToAncestor(
     const LayoutObject* layoutObject,
     const LayoutBoxModelObject* ancestorLayoutObject) {
   // We need to push mappings in reverse order here, so do insertions rather
   // than appends.
   AutoReset<size_t> positionChange(&m_insertionPosition, m_mapping.size());
   do {
     layoutObject =
         layoutObject->pushMappingToContainer(ancestorLayoutObject, *this);
   } while (layoutObject && layoutObject != ancestorLayoutObject);
 
-  ASSERT(m_mapping.isEmpty() ||
+#if DCHECK_IS_ON()
+  DCHECK(m_mapping.isEmpty() ||
          isTopmostLayoutView(m_mapping[0].m_layoutObject));
+#endif
 }
 
 static bool canMapBetweenLayoutObjects(const LayoutObject& layoutObject,
                                        const LayoutObject& ancestor) {
   for (const LayoutObject* current = &layoutObject;;
        current = current->parent()) {
     const ComputedStyle& style = current->styleRef();
     if (style.position() == EPosition::kFixed ||
         style.isFlippedBlocksWritingMode() ||
         style.hasTransformRelatedProperty())
@@ skipping 14 matching lines @@
 }
 
 void LayoutGeometryMap::pushMappingsToAncestor(
     const PaintLayer* layer,
     const PaintLayer* ancestorLayer) {
   const LayoutObject& layoutObject = layer->layoutObject();
 
   bool crossDocument =
       ancestorLayer &&
       layoutObject.frame() != ancestorLayer->layoutObject().frame();
-  ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
+  DCHECK(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
 
   // We have to visit all the layoutObjects to detect flipped blocks. This might
   // defeat the gains from mapping via layers.
   bool canConvertInLayerTree =
       (ancestorLayer && !crossDocument)
           ? canMapBetweenLayoutObjects(layoutObject,
                                        ancestorLayer->layoutObject())
           : false;
 
   LAYOUT_GEOMETRY_MAP_LOG(
@@ skipping 25 matching lines @@
 }
 
 void LayoutGeometryMap::push(const LayoutObject* layoutObject,
                              const LayoutSize& offsetFromContainer,
                              GeometryInfoFlags flags,
                              LayoutSize offsetForFixedPosition) {
   LAYOUT_GEOMETRY_MAP_LOG("LayoutGeometryMap::push %p %d,%d isNonUniform=%d\n",
                           layoutObject, offsetFromContainer.width().toInt(),
                           offsetFromContainer.height().toInt(), isNonUniform);
 
-  ASSERT(m_insertionPosition != kNotFound);
-  ASSERT(!layoutObject->isLayoutView() || !m_insertionPosition ||
+  DCHECK_NE(m_insertionPosition, kNotFound);
+  DCHECK(!layoutObject->isLayoutView() || !m_insertionPosition ||
          m_mapCoordinatesFlags & TraverseDocumentBoundaries);
-  ASSERT(offsetForFixedPosition.isZero() || layoutObject->isLayoutView());
+  DCHECK(offsetForFixedPosition.isZero() || layoutObject->isLayoutView());
 
   m_mapping.insert(m_insertionPosition,
                    LayoutGeometryMapStep(layoutObject, flags));
 
   LayoutGeometryMapStep& step = m_mapping[m_insertionPosition];
   step.m_offset = offsetFromContainer;
   step.m_offsetForFixedPosition = offsetForFixedPosition;
 
   stepInserted(step);
 }
 
 void LayoutGeometryMap::push(const LayoutObject* layoutObject,
                              const TransformationMatrix& t,
                              GeometryInfoFlags flags,
                              LayoutSize offsetForFixedPosition) {
-  ASSERT(m_insertionPosition != kNotFound);
-  ASSERT(!layoutObject->isLayoutView() || !m_insertionPosition ||
+  DCHECK_NE(m_insertionPosition, kNotFound);
+  DCHECK(!layoutObject->isLayoutView() || !m_insertionPosition ||
          m_mapCoordinatesFlags & TraverseDocumentBoundaries);
-  ASSERT(offsetForFixedPosition.isZero() || layoutObject->isLayoutView());
+  DCHECK(offsetForFixedPosition.isZero() || layoutObject->isLayoutView());
 
   m_mapping.insert(m_insertionPosition,
                    LayoutGeometryMapStep(layoutObject, flags));
 
   LayoutGeometryMapStep& step = m_mapping[m_insertionPosition];
   step.m_offsetForFixedPosition = offsetForFixedPosition;
 
   if (!t.isIntegerTranslation())
     step.m_transform = TransformationMatrix::create(t);
   else
     step.m_offset = LayoutSize(LayoutUnit(t.e()), LayoutUnit(t.f()));
 
   stepInserted(step);
 }
 
 void LayoutGeometryMap::popMappingsToAncestor(
     const LayoutBoxModelObject* ancestorLayoutObject) {
-  ASSERT(m_mapping.size());
+  DCHECK(m_mapping.size());
 
   bool mightBeSaturated = false;
   while (m_mapping.size() &&
          m_mapping.back().m_layoutObject != ancestorLayoutObject) {
     mightBeSaturated =
         mightBeSaturated || m_accumulatedOffset.width().mightBeSaturated();
     mightBeSaturated =
         mightBeSaturated || m_accumulatedOffset.height().mightBeSaturated();
     stepRemoved(m_mapping.back());
     m_mapping.pop_back();
@@ skipping 21 matching lines @@
     ++m_transformedStepsCount;
 
   if (step.m_flags & IsFixedPosition)
     ++m_fixedStepsCount;
 }
 
 void LayoutGeometryMap::stepRemoved(const LayoutGeometryMapStep& step) {
   m_accumulatedOffset -= step.m_offset;
 
   if (step.m_flags & IsNonUniform) {
-    ASSERT(m_nonUniformStepsCount);
+    DCHECK(m_nonUniformStepsCount);
     --m_nonUniformStepsCount;
   }
 
   if (step.m_transform) {
-    ASSERT(m_transformedStepsCount);
+    DCHECK(m_transformedStepsCount);
     --m_transformedStepsCount;
   }
 
   if (step.m_flags & IsFixedPosition) {
-    ASSERT(m_fixedStepsCount);
+    DCHECK(m_fixedStepsCount);
     --m_fixedStepsCount;
   }
 }
 
 #if DCHECK_IS_ON()
 bool LayoutGeometryMap::isTopmostLayoutView(
     const LayoutObject* layoutObject) const {
   if (!layoutObject->isLayoutView())
     return false;
 
   // If we're not working with multiple LayoutViews, then any view is considered
   // "topmost" (to preserve original behavior).
   if (!(m_mapCoordinatesFlags & TraverseDocumentBoundaries))
     return true;
 
   return layoutObject->frame()->isMainFrame();
 }
 #endif
 
 }  // namespace blink