Replace ASSERT with DCHECK in core/layout/<sub dirs>

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 178 matching lines @@
 
 CompositedLayerMapping::~CompositedLayerMapping() {
   // Hits in compositing/squashing/squash-onto-nephew.html.
   DisableCompositingQueryAsserts disabler;
 
   // Do not leave the destroyed pointer dangling on any Layers that painted to
   // this mapping's squashing layer.
   for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
     PaintLayer* oldSquashedLayer = m_squashedLayers[i].paintLayer;
     // Assert on incorrect mappings between layers and groups
-    ASSERT(oldSquashedLayer->groupedMapping() == this);
+    DCHECK_EQ(oldSquashedLayer->groupedMapping(), this);
     if (oldSquashedLayer->groupedMapping() == this) {
       oldSquashedLayer->setGroupedMapping(
           0, PaintLayer::DoNotInvalidateLayerAndRemoveFromMapping);
       oldSquashedLayer->setLostGroupedMapping(true);
     }
   }
 
   updateClippingLayers(false, false, false);
   updateOverflowControlsLayers(false, false, false, false);
   updateChildTransformLayer(false);
@@ skipping 190 matching lines @@
 }
 
 void CompositedLayerMapping::updateLayerBlendMode(const ComputedStyle& style) {
   setBlendMode(style.blendMode());
 }
 
 void CompositedLayerMapping::updateIsRootForIsolatedGroup() {
   bool isolate = m_owningLayer.shouldIsolateCompositedDescendants();
 
   // non stacking context layers should never isolate
-  ASSERT(m_owningLayer.stackingNode()->isStackingContext() || !isolate);
+  DCHECK(m_owningLayer.stackingNode()->isStackingContext() || !isolate);
 
   m_graphicsLayer->setIsRootForIsolatedGroup(isolate);
 }
 
 void CompositedLayerMapping::
     updateBackgroundPaintsOntoScrollingContentsLayer() {
   // We can only paint the background onto the scrolling contents layer if
   // it would be visually correct and we are using composited scrolling meaning
   // we have a scrolling contents layer to paint it into.
   BackgroundPaintLocation paintLocation =
@@ skipping 78 matching lines @@
     } else {
       if (hasScrollingLayer())
         m_scrollingContentsLayer->setContentsOpaque(false);
       m_graphicsLayer->setContentsOpaque(
           m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     }
   }
 }
 
 void CompositedLayerMapping::updateCompositedBounds() {
-  ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
-         DocumentLifecycle::InCompositingUpdate);
+  DCHECK_EQ(m_owningLayer.compositor()->lifecycle().state(),
+            DocumentLifecycle::InCompositingUpdate);
   // FIXME: if this is really needed for performance, it would be better to
   // store it on Layer.
   m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
   m_contentOffsetInCompositingLayerDirty = true;
 }
 
 void CompositedLayerMapping::updateAfterPartResize() {
   if (layoutObject().isLayoutPart()) {
     if (PaintLayerCompositor* innerCompositor =
             PaintLayerCompositor::frameContentsCompositor(
                 toLayoutPart(layoutObject()))) {
       innerCompositor->frameViewDidChangeSize();
       // We can floor this point because our frameviews are always aligned to
       // pixel boundaries.
-      ASSERT(m_compositedBounds.location() ==
+      DCHECK(m_compositedBounds.location() ==
              flooredIntPoint(m_compositedBounds.location()));
       innerCompositor->frameViewDidChangeLocation(
           flooredIntPoint(contentsBox().location()));
     }
   }
 }
 
 void CompositedLayerMapping::updateCompositingReasons() {
   // All other layers owned by this mapping will have the same compositing
   // reason for their lifetime, so they are initialized only when created.
@@ skipping 77 matching lines @@
 }
 
 const PaintLayer* CompositedLayerMapping::scrollParent() {
   const PaintLayer* scrollParent = m_owningLayer.scrollParent();
   if (scrollParent && !scrollParent->needsCompositedScrolling())
     return nullptr;
   return scrollParent;
 }
 
 bool CompositedLayerMapping::updateGraphicsLayerConfiguration() {
-  ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
-         DocumentLifecycle::InCompositingUpdate);
+  DCHECK_EQ(m_owningLayer.compositor()->lifecycle().state(),
+            DocumentLifecycle::InCompositingUpdate);
 
   // Note carefully: here we assume that the compositing state of all
   // descendants have been updated already, so it is legitimate to compute and
   // cache the composited bounds for this layer.
   updateCompositedBounds();
 
   PaintLayerCompositor* compositor = this->compositor();
   LayoutObject& layoutObject = this->layoutObject();
   const ComputedStyle& style = layoutObject.styleRef();
 
@@ skipping 381 matching lines @@
 
   for (size_t i = 0; i < layers.size(); ++i)
     layers[i].localClipRectForSquashedLayer =
         localClipRectForSquashedLayer(m_owningLayer, layers[i], layers);
 }
 
 void CompositedLayerMapping::updateGraphicsLayerGeometry(
     const PaintLayer* compositingContainer,
     const PaintLayer* compositingStackingContext,
     Vector<PaintLayer*>& layersNeedingPaintInvalidation) {
-  ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
-         DocumentLifecycle::InCompositingUpdate);
+  DCHECK_EQ(m_owningLayer.compositor()->lifecycle().state(),
+            DocumentLifecycle::InCompositingUpdate);
 
   // Set transform property, if it is not animating. We have to do this here
   // because the transform is affected by the layer dimensions.
   if (!layoutObject().style()->isRunningTransformAnimationOnCompositor())
     updateTransform(layoutObject().styleRef());
 
   // Set opacity, if it is not animating.
   if (!layoutObject().style()->isRunningOpacityAnimationOnCompositor())
     updateOpacity(layoutObject().styleRef());
 
   if (!layoutObject().style()->isRunningFilterAnimationOnCompositor())
     updateFilters(layoutObject().styleRef());
 
   if (!layoutObject().style()->isRunningBackdropFilterAnimationOnCompositor())
     updateBackdropFilters(layoutObject().styleRef());
 
   // We compute everything relative to the enclosing compositing layer.
   IntRect ancestorCompositingBounds;
   if (compositingContainer) {
-    ASSERT(compositingContainer->hasCompositedLayerMapping());
+    DCHECK(compositingContainer->hasCompositedLayerMapping());
     ancestorCompositingBounds = compositingContainer->compositedLayerMapping()
                                     ->pixelSnappedCompositedBounds();
   }
 
   IntRect localCompositingBounds;
   IntRect relativeCompositingBounds;
   LayoutPoint offsetFromCompositedAncestor;
   IntPoint snappedOffsetFromCompositedAncestor;
   computeBoundsOfOwningLayer(
       compositingContainer, localCompositingBounds, relativeCompositingBounds,
@@ skipping 340 matching lines @@
         relativeCompositingBounds.height() * 0.5f, 0.f);
     m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
   }
 }
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(
     const IntRect& localCompositingBounds) {
   if (!m_scrollingLayer)
     return;
 
-  ASSERT(m_scrollingContentsLayer);
+  DCHECK(m_scrollingContentsLayer);
   LayoutBox& layoutBox = toLayoutBox(layoutObject());
   IntRect overflowClipRect =
       pixelSnappedIntRect(layoutBox.overflowClipRect(LayoutPoint()));
 
   // When a m_childTransformLayer exists, local content offsets for the
   // m_scrollingLayer have already been applied. Otherwise, we apply them here.
   IntSize localContentOffset(0, 0);
   if (!m_childTransformLayer) {
     localContentOffset = roundedIntPoint(m_owningLayer.subpixelAccumulation()) -
                          localCompositingBounds.location();
@@ skipping 208 matching lines @@
     m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
   if (m_layerForScrollCorner)
     m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
 
   // Now add the DecorationOutlineLayer as a subtree to GraphicsLayer
   if (m_decorationOutlineLayer.get())
     m_graphicsLayer->addChild(m_decorationOutlineLayer.get());
 
   // The squashing containment layer, if it exists, becomes a no-op parent.
   if (m_squashingLayer) {
-    ASSERT((m_ancestorClippingLayer && !m_squashingContainmentLayer) ||
+    DCHECK((m_ancestorClippingLayer && !m_squashingContainmentLayer) ||
            (!m_ancestorClippingLayer && m_squashingContainmentLayer));
 
     if (m_squashingContainmentLayer) {
       m_squashingContainmentLayer->removeAllChildren();
       m_squashingContainmentLayer->addChild(m_graphicsLayer.get());
       m_squashingContainmentLayer->addChild(m_squashingLayer.get());
     } else {
       // The ancestor clipping layer is already set up and has m_graphicsLayer
       // under it.
       m_ancestorClippingLayer->addChild(m_squashingLayer.get());
@@ skipping 370 matching lines @@
        ApplyToContentLayers |
        ApplyToScrollingContentLayers |
        ApplyToDecorationOutlineLayer)
 };
 typedef unsigned ApplyToGraphicsLayersMode;
 
 template <typename Func>
 static void ApplyToGraphicsLayers(const CompositedLayerMapping* mapping,
                                   const Func& f,
                                   ApplyToGraphicsLayersMode mode) {
-  ASSERT(mode);
+  DCHECK(mode);
 
   if ((mode & ApplyToLayersAffectedByPreserve3D) &&
       mapping->childTransformLayer())
     f(mapping->childTransformLayer());
   if (((mode & ApplyToLayersAffectedByPreserve3D) ||
        (mode & ApplyToContentLayers) ||
        (mode & ApplyToNonScrollingContentLayers)) &&
       mapping->mainGraphicsLayer())
     f(mapping->mainGraphicsLayer());
   if (((mode & ApplyToLayersAffectedByPreserve3D) ||
@@ skipping 414 matching lines @@
       }
     } else {
       if (!m_squashingContainmentLayer) {
         m_squashingContainmentLayer =
             createGraphicsLayer(CompositingReasonLayerForSquashingContainer);
         m_squashingContainmentLayer->setShouldFlattenTransform(false);
         layersChanged = true;
       }
     }
 
-    ASSERT((m_ancestorClippingLayer && !m_squashingContainmentLayer) ||
+    DCHECK((m_ancestorClippingLayer && !m_squashingContainmentLayer) ||
            (!m_ancestorClippingLayer && m_squashingContainmentLayer));
-    ASSERT(m_squashingLayer);
+    DCHECK(m_squashingLayer);
   } else {
     if (m_squashingLayer) {
       m_squashingLayer->removeFromParent();
       m_squashingLayer = nullptr;
       layersChanged = true;
     }
     if (m_squashingContainmentLayer) {
       m_squashingContainmentLayer->removeFromParent();
       m_squashingContainmentLayer = nullptr;
       layersChanged = true;
     }
-    ASSERT(!m_squashingLayer && !m_squashingContainmentLayer);
+    DCHECK(!m_squashingLayer);
+    DCHECK(!m_squashingContainmentLayer);
   }
 
   return layersChanged;
 }
 
 GraphicsLayerPaintingPhase
 CompositedLayerMapping::paintingPhaseForPrimaryLayer() const {
   unsigned phase = 0;
   if (!m_backgroundLayer)
     phase |= GraphicsLayerPaintBackground;
@@ skipping 218 matching lines @@
   origin.setY(
       floatValueForLength(style.transformOriginY(), borderBox.height()));
   origin.setZ(style.transformOriginZ());
 
   return origin;
 }
 
 // Return the offset from the top-left of this compositing layer at which the
 // LayoutObject's contents are painted.
 LayoutSize CompositedLayerMapping::contentOffsetInCompositingLayer() const {
-  ASSERT(!m_contentOffsetInCompositingLayerDirty);
+  DCHECK(!m_contentOffsetInCompositingLayerDirty);
   return m_contentOffsetInCompositingLayer;
 }
 
 LayoutRect CompositedLayerMapping::contentsBox() const {
   LayoutRect contentsBox = LayoutRect(contentsRect(layoutObject()));
   contentsBox.move(contentOffsetInCompositingLayer());
   return contentsBox;
 }
 
 bool CompositedLayerMapping::needsToReparentOverflowControls() const {
@@ skipping 102 matching lines @@
   const DisplayItemClient& client;
 };
 
 void CompositedLayerMapping::setContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
   DCHECK(!m_owningLayer.layoutObject().usesCompositedScrolling());
   // TODO(wangxianzhu): Enable the following assert after paint invalidation for
   // spv2 is ready.
-  // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+  // DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToContentLayers);
 }
 
 void CompositedLayerMapping::setNonScrollingContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
   DCHECK(m_owningLayer.layoutObject().usesCompositedScrolling());
   // TODO(wangxianzhu): Enable the following assert after paint invalidation for
   // spv2 is ready.
-  // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+  // DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToNonScrollingContentLayers);
 }
 
 void CompositedLayerMapping::setScrollingContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
   DCHECK(m_owningLayer.layoutObject().usesCompositedScrolling());
   // TODO(wangxianzhu): Enable the following assert after paint invalidation for
   // spv2 is ready.
-  // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+  // DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToScrollingContentLayers);
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(
     const LayoutObject* layoutObject,
@@ skipping 17 matching lines @@
 
 IntRect CompositedLayerMapping::localClipRectForSquashedLayer(
     const PaintLayer& referenceLayer,
     const GraphicsLayerPaintInfo& paintInfo,
     const Vector<GraphicsLayerPaintInfo>& layers) {
   const LayoutObject* clippingContainer =
       paintInfo.paintLayer->clippingContainer();
   if (clippingContainer == referenceLayer.clippingContainer())
     return LayoutRect::infiniteIntRect();
 
-  ASSERT(clippingContainer);
+  DCHECK(clippingContainer);
 
   const GraphicsLayerPaintInfo* ancestorPaintInfo =
       containingSquashedLayer(clippingContainer, layers, layers.size());
   // Must be there, otherwise
   // CompositingLayerAssigner::canSquashIntoCurrentSquashingOwner would have
   // disallowed squashing.
-  ASSERT(ancestorPaintInfo);
+  DCHECK(ancestorPaintInfo);
 
   // FIXME: this is a potential performance issue. We should consider caching
   // these clip rects or otherwise optimizing.
   ClipRectsContext clipRectsContext(ancestorPaintInfo->paintLayer,
                                     UncachedClipRects);
   ClipRect parentClipRect;
   paintInfo.paintLayer->clipper(PaintLayer::DoNotUseGeometryMapper)
       .calculateBackgroundClipRect(clipRectsContext, parentClipRect);
 
   IntRect snappedParentClipRect(pixelSnappedIntRect(parentClipRect.rect()));
@@ skipping 116 matching lines @@
     // yet m_squashedLayers.size() == 0. There must be a bug elsewhere.
     if (m_squashedLayers.size() == 0)
       return IntRect();
     // All squashed layers have the same clip and transform space, so we can use
     // the first squashed layer's layoutObject to map the squashing layer's
     // bounds into viewport space, with offsetFromAnchorLayoutObject to
     // translate squashing layer's bounds into the first squashed layer's space.
     anchorLayoutObject = &m_squashedLayers[0].paintLayer->layoutObject();
     offsetFromAnchorLayoutObject = m_squashedLayers[0].offsetFromLayoutObject;
   } else {
-    ASSERT(graphicsLayer == m_graphicsLayer.get() ||
+    DCHECK(graphicsLayer == m_graphicsLayer.get() ||
            graphicsLayer == m_scrollingContentsLayer.get());
     anchorLayoutObject = &m_owningLayer.layoutObject();
     offsetFromAnchorLayoutObject = graphicsLayer->offsetFromLayoutObject();
     adjustForCompositedScrolling(graphicsLayer, offsetFromAnchorLayoutObject);
   }
 
   // Start with the bounds of the graphics layer in the space of the anchor
   // LayoutObject.
   FloatRect graphicsLayerBoundsInObjectSpace(graphicsLayerBounds);
   graphicsLayerBoundsInObjectSpace.move(offsetFromAnchorLayoutObject);
@@ skipping 375 matching lines @@
 
 void CompositedLayerMapping::removeLayerFromSquashingGraphicsLayer(
     const PaintLayer* layer) {
   size_t layerIndex = 0;
   for (; layerIndex < m_squashedLayers.size(); ++layerIndex) {
     if (m_squashedLayers[layerIndex].paintLayer == layer)
       break;
   }
 
   // Assert on incorrect mappings between layers and groups
-  ASSERT(layerIndex < m_squashedLayers.size());
+  DCHECK_LT(layerIndex, m_squashedLayers.size());
   if (layerIndex == m_squashedLayers.size())
     return;
 
   m_squashedLayers.remove(layerIndex);
 }
 
 #if DCHECK_IS_ON()
 bool CompositedLayerMapping::verifyLayerInSquashingVector(
     const PaintLayer* layer) {
   for (size_t layerIndex = 0; layerIndex < m_squashedLayers.size();
@@ skipping 72 matching lines @@
   } else if (graphicsLayer == m_decorationOutlineLayer.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink