Don't apply clips to children of composited-scrolling elements for overlap testing.

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 88 matching lines @@
 static CompositingQueryMode gCompositingQueryMode =
     CompositingQueriesAreOnlyAllowedInCertainDocumentLifecyclePhases;
 
 struct SameSizeAsPaintLayer : DisplayItemClient {
   int bitFields;
   void* pointers[10];
   LayoutUnit layoutUnits[4];
   IntSize size;
   Persistent<PaintLayerScrollableArea> scrollableArea;
   struct {
-    IntRect rect;
+    IntRect rect, rect2;
     void* pointers[2];
   } ancestorCompositingInputs;
   struct {
     IntSize size;
     void* pointer;
     LayoutRect rect;
   } previousPaintStatus;
 };
 
 static_assert(sizeof(PaintLayer) == sizeof(SameSizeAsPaintLayer),
@@ skipping 13 matching lines @@
 PaintLayerRareData::~PaintLayerRareData() {}
 
 PaintLayer::PaintLayer(LayoutBoxModelObject* layoutObject)
     : m_hasSelfPaintingLayerDescendant(false),
       m_hasSelfPaintingLayerDescendantDirty(false),
       m_isRootLayer(layoutObject->isLayoutView()),
       m_isVisibleContentDirty(true),
       m_hasVisibleContent(false),
       m_isVisibleDescendantDirty(false),
       m_hasVisibleDescendant(false),
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       m_needsPositionUpdate(true),
 #endif
       m_is3DTransformedDescendantDirty(true),
       m_has3DTransformedDescendant(false),
       m_containsDirtyOverlayScrollbars(false),
       m_needsAncestorDependentCompositingInputsUpdate(true),
       m_needsDescendantDependentCompositingInputsUpdate(true),
       m_childNeedsCompositingInputsUpdate(true),
       m_hasCompositingDescendant(false),
       m_isAllScrollingContentComposited(false),
@@ skipping 157 matching lines @@
   // FIXME: We should be able to remove this call because we don't care about
   // any descendant-dependent flags, but code somewhere else is reading these
   // flags and depending on us to update them.
   updateDescendantDependentFlags();
 
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling())
     child->updateLayerPositionRecursive();
 }
 
 void PaintLayer::updateHasSelfPaintingLayerDescendant() const {
-  ASSERT(m_hasSelfPaintingLayerDescendantDirty);
+  DCHECK(m_hasSelfPaintingLayerDescendantDirty);
 
   m_hasSelfPaintingLayerDescendant = false;
 
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling()) {
     if (child->isSelfPaintingLayer() ||
         child->hasSelfPaintingLayerDescendant()) {
       m_hasSelfPaintingLayerDescendant = true;
       break;
     }
   }
 
   m_hasSelfPaintingLayerDescendantDirty = false;
 }
 
 void PaintLayer::dirtyAncestorChainHasSelfPaintingLayerDescendantStatus() {
   for (PaintLayer* layer = this; layer; layer = layer->parent()) {
     layer->m_hasSelfPaintingLayerDescendantDirty = true;
     // If we have reached a self-painting layer, we know our parent should have
     // a self-painting descendant in this case, there is no need to dirty our
     // ancestors further.
     if (layer->isSelfPaintingLayer()) {
-      ASSERT(!parent() || parent()->m_hasSelfPaintingLayerDescendantDirty ||
+      DCHECK(!parent() || parent()->m_hasSelfPaintingLayerDescendantDirty ||
              parent()->m_hasSelfPaintingLayerDescendant);
       break;
     }
   }
 }
 
 bool PaintLayer::scrollsWithViewport() const {
   return (layoutObject()->style()->position() == FixedPosition &&
           layoutObject()->containerForFixedPosition() ==
               layoutObject()->view()) ||
@@ skipping 34 matching lines @@
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling()) {
     child->updateLayerPositionsAfterScrollRecursive(
         scrollDelta, paintInvalidationContainerWasScrolled &&
                          !child->isPaintInvalidationContainer());
   }
 }
 
 void PaintLayer::updateTransformationMatrix() {
   if (TransformationMatrix* transform = this->transform()) {
     LayoutBox* box = layoutBox();
-    ASSERT(box);
+    DCHECK(box);
     transform->makeIdentity();
     box->style()->applyTransform(
         *transform, box->size(), ComputedStyle::IncludeTransformOrigin,
         ComputedStyle::IncludeMotionPath,
         ComputedStyle::IncludeIndependentTransformProperties);
     makeMatrixRenderable(*transform, compositor()->hasAcceleratedCompositing());
   }
 }
 
 void PaintLayer::updateTransform(const ComputedStyle* oldStyle,
@@ skipping 90 matching lines @@
     return matrix;
   }
 
   return *transform;
 }
 
 void PaintLayer::convertFromFlowThreadToVisualBoundingBoxInAncestor(
     const PaintLayer* ancestorLayer,
     LayoutRect& rect) const {
   PaintLayer* paginationLayer = enclosingPaginationLayer();
-  ASSERT(paginationLayer);
+  DCHECK(paginationLayer);
   LayoutFlowThread* flowThread =
       toLayoutFlowThread(paginationLayer->layoutObject());
 
   // First make the flow thread rectangle relative to the flow thread, not to
   // |layer|.
   LayoutPoint offsetWithinPaginationLayer;
   convertToLayerCoords(paginationLayer, offsetWithinPaginationLayer);
   rect.moveBy(offsetWithinPaginationLayer);
 
   // Then make the rectangle visual, relative to the fragmentation context.
@@ skipping 339 matching lines @@
     localPoint.move(newOffset);
   } else if (m_rareData) {
     m_rareData->offsetForInFlowPosition = LayoutSize();
   }
 
   if (m_location != localPoint) {
     setNeedsRepaint();
   }
   m_location = localPoint;
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   m_needsPositionUpdate = false;
 #endif
 }
 
 TransformationMatrix PaintLayer::perspectiveTransform() const {
   if (!layoutObject()->hasTransformRelatedProperty())
     return TransformationMatrix();
 
   const ComputedStyle& style = layoutObject()->styleRef();
   if (!style.hasPerspective())
@@ skipping 15 matching lines @@
                                         borderBox.width().toFloat()),
                     floatValueForLength(style.perspectiveOriginY(),
                                         borderBox.height().toFloat()));
 }
 
 PaintLayer* PaintLayer::containingLayerForOutOfFlowPositioned(
     const PaintLayer* ancestor,
     bool* skippedAncestor) const {
   // If we have specified an ancestor, surely the caller needs to know whether
   // we skipped it.
-  ASSERT(!ancestor || skippedAncestor);
+  DCHECK(!ancestor || skippedAncestor);
   if (skippedAncestor)
     *skippedAncestor = false;
   if (layoutObject()->style()->position() == FixedPosition) {
     PaintLayer* curr = parent();
     while (curr && !curr->layoutObject()->canContainFixedPositionObjects()) {
       if (skippedAncestor && curr == ancestor)
         *skippedAncestor = true;
       curr = curr->parent();
     }
 
@@ skipping 40 matching lines @@
 bool PaintLayer::isPaintInvalidationContainer() const {
   return compositingState() == PaintsIntoOwnBacking ||
          compositingState() == PaintsIntoGroupedBacking;
 }
 
 // Note: enclosingCompositingLayer does not include squashed layers. Compositing
 // stacking children of squashed layers receive graphics layers that are
 // parented to the compositing ancestor of the squashed layer.
 PaintLayer* PaintLayer::enclosingLayerWithCompositedLayerMapping(
     IncludeSelfOrNot includeSelf) const {
-  ASSERT(isAllowedToQueryCompositingState());
+  DCHECK(isAllowedToQueryCompositingState());
 
   if ((includeSelf == IncludeSelf) && compositingState() != NotComposited &&
       compositingState() != PaintsIntoGroupedBacking)
     return const_cast<PaintLayer*>(this);
 
   for (PaintLayer* curr = compositingContainer(); curr;
        curr = curr->compositingContainer()) {
     if (curr->compositingState() != NotComposited &&
         curr->compositingState() != PaintsIntoGroupedBacking)
       return curr;
   }
 
   return nullptr;
 }
 
 // Return the enclosingCompositedLayerForPaintInvalidation for the given Layer
 // including crossing frame boundaries.
 PaintLayer*
 PaintLayer::enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const {
   const PaintLayer* layer = this;
   PaintLayer* compositedLayer = 0;
   while (!compositedLayer) {
     compositedLayer = layer->enclosingLayerForPaintInvalidation();
     if (!compositedLayer) {
-      RELEASE_ASSERT(layer->layoutObject()->frame());
+      CHECK(layer->layoutObject()->frame());
       LayoutItem owner = layer->layoutObject()->frame()->ownerLayoutItem();
       if (owner.isNull())
         break;
       layer = owner.enclosingLayer();
     }
   }
   return compositedLayer;
 }
 
 PaintLayer* PaintLayer::enclosingLayerForPaintInvalidation() const {
-  ASSERT(isAllowedToQueryCompositingState());
+  DCHECK(isAllowedToQueryCompositingState());
 
   if (isPaintInvalidationContainer())
     return const_cast<PaintLayer*>(this);
 
   for (PaintLayer* curr = compositingContainer(); curr;
        curr = curr->compositingContainer()) {
     if (curr->isPaintInvalidationContainer())
       return curr;
   }
 
@@ skipping 32 matching lines @@
     bool hasNonIsolatedDescendantWithBlendMode,
     bool hasRootScrollerAsDescendant) {
   m_hasDescendantWithClipPath = hasDescendantWithClipPath;
   m_hasNonIsolatedDescendantWithBlendMode =
       hasNonIsolatedDescendantWithBlendMode;
   m_hasRootScrollerAsDescendant = hasRootScrollerAsDescendant;
   m_needsDescendantDependentCompositingInputsUpdate = false;
 }
 
 void PaintLayer::didUpdateCompositingInputs() {
-  ASSERT(!needsCompositingInputsUpdate());
+  DCHECK(!needsCompositingInputsUpdate());
   m_childNeedsCompositingInputsUpdate = false;
   if (m_scrollableArea)
     m_scrollableArea->updateNeedsCompositedScrolling();
 }
 
 bool PaintLayer::hasNonIsolatedDescendantWithBlendMode() const {
-  ASSERT(!m_needsDescendantDependentCompositingInputsUpdate);
+  DCHECK(!m_needsDescendantDependentCompositingInputsUpdate);
   if (m_hasNonIsolatedDescendantWithBlendMode)
     return true;
   if (layoutObject()->isSVGRoot())
     return toLayoutSVGRoot(layoutObject())->hasNonIsolatedBlendingDescendants();
   return false;
 }
 
 void PaintLayer::setCompositingReasons(CompositingReasons reasons,
                                        CompositingReasons mask) {
   CompositingReasons oldReasons =
@@ skipping 163 matching lines @@
 void PaintLayer::operator delete(void* ptr) {
   partitionFree(ptr);
 }
 
 void PaintLayer::addChild(PaintLayer* child, PaintLayer* beforeChild) {
   PaintLayer* prevSibling =
       beforeChild ? beforeChild->previousSibling() : lastChild();
   if (prevSibling) {
     child->setPreviousSibling(prevSibling);
     prevSibling->setNextSibling(child);
-    ASSERT(prevSibling != child);
+    DCHECK(prevSibling != child);
   } else {
     setFirstChild(child);
   }
 
   if (beforeChild) {
     beforeChild->setPreviousSibling(child);
     child->setNextSibling(beforeChild);
-    ASSERT(beforeChild != child);
+    DCHECK(beforeChild != child);
   } else {
     setLastChild(child);
   }
 
   child->m_parent = this;
 
   // The ancestor overflow layer is calculated during compositing inputs update
   // and should not be set yet.
-  ASSERT(!child->ancestorOverflowLayer());
+  DCHECK(!child->ancestorOverflowLayer());
 
   setNeedsCompositingInputsUpdate();
 
   if (!child->stackingNode()->isStacked() &&
       !layoutObject()->documentBeingDestroyed())
     compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 
   if (child->stackingNode()->isStacked() || child->firstChild()) {
     // Dirty the z-order list in which we are contained. The
     // ancestorStackingContextNode() can be null in the case where we're
@@ skipping 110 matching lines @@
   // Remove us from the parent.
   m_parent->removeChild(this);
   m_layoutObject->destroyLayer();
 }
 
 void PaintLayer::insertOnlyThisLayerAfterStyleChange() {
   if (!m_parent && layoutObject()->parent()) {
     // We need to connect ourselves when our layoutObject() has a parent.
     // Find our enclosingLayer and add ourselves.
     PaintLayer* parentLayer = layoutObject()->parent()->enclosingLayer();
-    ASSERT(parentLayer);
+    DCHECK(parentLayer);
     PaintLayer* beforeChild =
         layoutObject()->parent()->findNextLayer(parentLayer, layoutObject());
     parentLayer->addChild(this, beforeChild);
   }
 
   // Remove all descendant layers from the hierarchy and add them to the new
   // position.
   for (LayoutObject* curr = layoutObject()->slowFirstChild(); curr;
        curr = curr->nextSibling())
     curr->moveLayers(m_parent, this);
@@ skipping 25 matching lines @@
 
   // Clear out all the clip rects.
   clipper().clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const PaintLayer* accumulateOffsetTowardsAncestor(
     const PaintLayer* layer,
     const PaintLayer* ancestorLayer,
     LayoutPoint& location) {
-  ASSERT(ancestorLayer != layer);
+  DCHECK(ancestorLayer != layer);
 
   const LayoutBoxModelObject* layoutObject = layer->layoutObject();
   EPosition position = layoutObject->style()->position();
 
   if (position == FixedPosition &&
       (!ancestorLayer || ancestorLayer == layoutObject->view()->layer())) {
     // If the fixed layer's container is the root, just add in the offset of the
     // view. We can obtain this by calling localToAbsolute() on the LayoutView.
     FloatPoint absPos = layoutObject->localToAbsolute();
     location += LayoutSize(absPos.x(), absPos.y());
@@ skipping 14 matching lines @@
       layer->convertToLayerCoords(parentLayer, thisCoords);
 
       LayoutPoint ancestorCoords;
       ancestorLayer->convertToLayerCoords(parentLayer, ancestorCoords);
 
       location += (thisCoords - ancestorCoords);
       return ancestorLayer;
     }
   } else if (layoutObject->isColumnSpanAll()) {
     LayoutBlock* multicolContainer = layoutObject->containingBlock();
-    ASSERT(toLayoutBlockFlow(multicolContainer)->multiColumnFlowThread());
+    DCHECK(toLayoutBlockFlow(multicolContainer)->multiColumnFlowThread());
     parentLayer = multicolContainer->layer();
-    ASSERT(parentLayer);
+    DCHECK(parentLayer);
   } else {
     parentLayer = layer->parent();
   }
 
   if (!parentLayer)
     return nullptr;
 
   location += layer->location();
   return parentLayer;
 }
@@ skipping 53 matching lines @@
 
   // If the floating object becomes non-self-painting, so some ancestor should
   // paint it; if it becomes self-painting, it should paint itself and no
   // ancestor should paint it.
   if (wasSelfPaintingLayer != isSelfPaintingLayer() &&
       m_layoutObject->isFloating())
     LayoutBlockFlow::setAncestorShouldPaintFloatingObject(*layoutBox());
 }
 
 void PaintLayer::updateStackingNode() {
-  ASSERT(!m_stackingNode);
+  DCHECK(!m_stackingNode);
   if (requiresStackingNode())
     m_stackingNode = wrapUnique(new PaintLayerStackingNode(this));
   else
     m_stackingNode = nullptr;
 }
 
 void PaintLayer::updateScrollableArea() {
-  ASSERT(!m_scrollableArea);
+  DCHECK(!m_scrollableArea);
   if (requiresScrollableArea())
     m_scrollableArea = PaintLayerScrollableArea::create(*this);
 }
 
 bool PaintLayer::hasOverflowControls() const {
   return m_scrollableArea && (m_scrollableArea->hasScrollbar() ||
                               m_scrollableArea->scrollCorner() ||
                               layoutObject()->style()->resize() != RESIZE_NONE);
 }
 
@@ skipping 167 matching lines @@
 
 static inline LayoutRect frameVisibleRect(LayoutObject* layoutObject) {
   FrameView* frameView = layoutObject->document().view();
   if (!frameView)
     return LayoutRect();
 
   return LayoutRect(frameView->visibleContentRect());
 }
 
 bool PaintLayer::hitTest(HitTestResult& result) {
-  ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
+  DCHECK(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
   // LayoutView should make sure to update layout before entering hit testing
-  ASSERT(!layoutObject()->frame()->view()->layoutPending());
-  ASSERT(!layoutObject()->document().layoutViewItem().needsLayout());
+  DCHECK(!layoutObject()->frame()->view()->layoutPending());
+  DCHECK(!layoutObject()->document().layoutViewItem().needsLayout());
 
   const HitTestRequest& request = result.hitTestRequest();
   const HitTestLocation& hitTestLocation = result.hitTestLocation();
 
   // Start with frameVisibleRect to ensure we include the scrollbars.
   LayoutRect hitTestArea = frameVisibleRect(layoutObject());
   if (request.ignoreClipping())
     hitTestArea.unite(LayoutRect(layoutObject()->view()->documentRect()));
 
   PaintLayer* insideLayer =
@@ skipping 120 matching lines @@
   if (!hitLayer)
     return false;
 
   // The hit layer is depth-sorting with other layers, so just say that it was
   // hit.
   if (canDepthSort)
     return true;
 
   // We need to look at z-depth to decide if this layer was hit.
   if (zOffset) {
-    ASSERT(transformState);
+    DCHECK(transformState);
     // This is actually computing our z, but that's OK because the hitLayer is
     // coplanar with us.
     double childZOffset = computeZOffset(*transformState);
     if (childZOffset > *zOffset) {
       *zOffset = childZOffset;
       return true;
     }
     return false;
   }
 
@@ skipping 60 matching lines @@
   // Ensure our lists and 3d status are up to date.
   m_stackingNode->updateLayerListsIfNeeded();
   update3DTransformedDescendantStatus();
 
   // The natural thing would be to keep HitTestingTransformState on the stack,
   // but it's big, so we heap-allocate.
   RefPtr<HitTestingTransformState> localTransformState;
   if (appliedTransform) {
     // We computed the correct state in the caller (above code), so just
     // reference it.
-    ASSERT(transformState);
+    DCHECK(transformState);
     localTransformState = const_cast<HitTestingTransformState*>(transformState);
   } else if (transformState || m_has3DTransformedDescendant || preserves3D()) {
     // We need transform state for the first time, or to offset the container
     // state, so create it here.
     localTransformState =
         createLocalTransformState(rootLayer, containerLayer, hitTestRect,
                                   hitTestLocation, transformState);
   }
 
   // Check for hit test on backface if backface-visibility is 'hidden'
@@ skipping 264 matching lines @@
   // Now do a hit test with the root layer shifted to be us.
   return hitTestLayer(this, containerLayer, result, localHitTestRect,
                       newHitTestLocation, true, newTransformState.get(),
                       zOffset);
 }
 
 bool PaintLayer::hitTestContents(HitTestResult& result,
                                  const LayoutRect& layerBounds,
                                  const HitTestLocation& hitTestLocation,
                                  HitTestFilter hitTestFilter) const {
-  ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
+  DCHECK(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
   if (!layoutObject()->hitTest(
           result, hitTestLocation,
           toLayoutPoint(layerBounds.location() - layoutBoxLocation()),
           hitTestFilter)) {
     // It's wrong to set innerNode, but then claim that you didn't hit anything,
     // unless it is a rect-based test.
-    ASSERT(!result.innerNode() || (result.hitTestRequest().listBased() &&
+    DCHECK(!result.innerNode() || (result.hitTestRequest().listBased() &&
                                    result.listBasedTestResult().size()));
     return false;
   }
 
   if (!result.innerNode()) {
     // We hit something anonymous, and we didn't find a DOM node ancestor in
     // this layer.
 
     if (layoutObject()->isLayoutFlowThread()) {
       // For a flow thread it's safe to just say that we didn't hit anything.
@@ skipping 37 matching lines @@
   while (PaintLayerStackingNode* child = iterator.next()) {
     PaintLayer* childLayer = child->layer();
     PaintLayer* hitLayer = 0;
     HitTestResult tempResult(result.hitTestRequest(), result.hitTestLocation());
     hitLayer = childLayer->hitTestLayer(rootLayer, this, tempResult,
                                         hitTestRect, hitTestLocation, false,
                                         transformState, zOffsetForDescendants);
 
     // If it is a list-based test, we can safely append the temporary result
     // since it might had hit nodes but not necesserily had hitLayer set.
-    ASSERT(!result.isRectBasedTest() || result.hitTestRequest().listBased());
+    DCHECK(!result.isRectBasedTest() || result.hitTestRequest().listBased());
     if (result.hitTestRequest().listBased())
       result.append(tempResult);
 
     if (isHitCandidate(hitLayer, depthSortDescendants, zOffset,
                        unflattenedTransformState)) {
       resultLayer = hitLayer;
       if (!result.hitTestRequest().listBased())
         result = tempResult;
       if (!depthSortDescendants)
         break;
@@ skipping 69 matching lines @@
                                       const LayoutPoint& offsetFromRoot) const {
   // Always examine the canvas and the root.
   // FIXME: Could eliminate the isDocumentElement() check if we fix background
   // painting so that the LayoutView paints the root's background.
   if (isRootLayer() || layoutObject()->isDocumentElement())
     return true;
 
   // If we aren't an inline flow, and our layer bounds do intersect the damage
   // rect, then we can go ahead and return true.
   LayoutView* view = layoutObject()->view();
-  ASSERT(view);
+  DCHECK(view);
   if (view && !layoutObject()->isLayoutInline()) {
     if (layerBounds.intersects(damageRect))
       return true;
   }
 
   // Otherwise we need to compute the bounding box of this single layer and see
   // if it intersects the damage rect.
   return physicalBoundingBox(offsetFromRoot).intersects(damageRect);
 }
 
@@ skipping 52 matching lines @@
 }
 
 bool PaintLayer::overlapBoundsIncludeChildren() const {
   return hasFilterThatMovesPixels();
 }
 
 static void expandRectForStackingChildren(
     const PaintLayer* ancestorLayer,
     LayoutRect& result,
     PaintLayer::CalculateBoundsOptions options) {
-  ASSERT(ancestorLayer->stackingNode()->isStackingContext() ||
+  DCHECK(ancestorLayer->stackingNode()->isStackingContext() ||
          !ancestorLayer->stackingNode()->hasPositiveZOrderList());
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   LayerListMutationDetector mutationChecker(
       const_cast<PaintLayer*>(ancestorLayer)->stackingNode());
 #endif
 
   PaintLayerStackingNodeIterator iterator(*ancestorLayer->stackingNode(),
                                           AllChildren);
   while (PaintLayerStackingNode* node = iterator.next()) {
     // Here we exclude both directly composited layers and squashing layers
     // because those Layers don't paint into the graphics layer
     // for this Layer. For example, the bounds of squashed Layers
@@ skipping 75 matching lines @@
     convertFromFlowThreadToVisualBoundingBoxInAncestor(ancestorLayer, result);
     return result;
   }
   LayoutPoint delta;
   convertToLayerCoords(ancestorLayer, delta);
   result.moveBy(delta);
   return result;
 }
 
 CompositingState PaintLayer::compositingState() const {
-  ASSERT(isAllowedToQueryCompositingState());
+  DCHECK(isAllowedToQueryCompositingState());
 
   // This is computed procedurally so there is no redundant state variable that
   // can get out of sync from the real actual compositing state.
 
   if (groupedMapping()) {
-    ASSERT(!compositedLayerMapping());
+    DCHECK(!compositedLayerMapping());
     return PaintsIntoGroupedBacking;
   }
 
   if (!compositedLayerMapping())
     return NotComposited;
 
   return PaintsIntoOwnBacking;
 }
 
 bool PaintLayer::isAllowedToQueryCompositingState() const {
   if (gCompositingQueryMode == CompositingQueriesAreAllowed ||
       RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return true;
   return layoutObject()->document().lifecycle().state() >=
          DocumentLifecycle::InCompositingUpdate;
 }
 
 CompositedLayerMapping* PaintLayer::compositedLayerMapping() const {
-  ASSERT(isAllowedToQueryCompositingState());
+  DCHECK(isAllowedToQueryCompositingState());
   return m_rareData ? m_rareData->compositedLayerMapping.get() : nullptr;
 }
 
 GraphicsLayer* PaintLayer::graphicsLayerBacking() const {
   switch (compositingState()) {
     case NotComposited:
       return 0;
     case PaintsIntoGroupedBacking:
       return groupedMapping()->squashingLayer();
     default:
@@ skipping 59 matching lines @@
   CompositedLayerMapping* oldGroupedMapping = this->groupedMapping();
   if (groupedMapping == oldGroupedMapping)
     return;
 
   if (options == InvalidateLayerAndRemoveFromMapping && oldGroupedMapping) {
     oldGroupedMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
     oldGroupedMapping->removeLayerFromSquashingGraphicsLayer(this);
   }
   if (m_rareData || groupedMapping)
     ensureRareData().groupedMapping = groupedMapping;
-  ASSERT(!groupedMapping || groupedMapping->verifyLayerInSquashingVector(this));
+#if DCHECK_IS_ON()
+  DCHECK(!groupedMapping || groupedMapping->verifyLayerInSquashingVector(this));
+#endif
   if (options == InvalidateLayerAndRemoveFromMapping && groupedMapping)
     groupedMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
 }
 
 bool PaintLayer::hasCompositedMask() const {
   return m_rareData && m_rareData->compositedLayerMapping &&
          m_rareData->compositedLayerMapping->hasMaskLayer();
 }
 
 bool PaintLayer::hasCompositedClippingMask() const {
@@ skipping 347 matching lines @@
 
 FilterEffect* PaintLayer::updateFilterEffect() const {
   // TODO(chrishtr): ensure (and assert) that compositing is clean here.
 
   if (!paintsWithFilters())
     return nullptr;
 
   PaintLayerFilterInfo* filterInfo = this->filterInfo();
 
   // Should have been added by updateOrRemoveFilterEffect().
-  ASSERT(filterInfo);
+  DCHECK(filterInfo);
 
   if (filterInfo->lastEffect())
     return filterInfo->lastEffect();
 
   const ComputedStyle& style = layoutObject()->styleRef();
   FloatRect zoomedReferenceBox;
   if (style.filter().hasReferenceFilter())
     zoomedReferenceBox = boxForFilter();
   FilterEffectBuilder builder(enclosingNode(), zoomedReferenceBox,
                               style.effectiveZoom());
@@ skipping 197 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif