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

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

 /*
  * Copyright (C) 2009, 2010 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 @@
       m_rootShouldAlwaysCompositeDirty(true),
       m_needsUpdateFixedBackground(false),
       m_isTrackingRasterInvalidations(
           layoutView.frameView()->isTrackingPaintInvalidations()),
       m_inOverlayFullscreenVideo(false),
       m_rootLayerAttachment(RootLayerUnattached) {
   updateAcceleratedCompositingSettings();
 }
 
 PaintLayerCompositor::~PaintLayerCompositor() {
-  ASSERT(m_rootLayerAttachment == RootLayerUnattached);
+  DCHECK_EQ(m_rootLayerAttachment, RootLayerUnattached);
 }
 
 bool PaintLayerCompositor::inCompositingMode() const {
   // FIXME: This should assert that lifecycle is >= CompositingClean since
   // the last step of updateIfNeeded can set this bit to false.
-  ASSERT(m_layoutView.layer()->isAllowedToQueryCompositingState());
+  DCHECK(m_layoutView.layer()->isAllowedToQueryCompositingState());
   return m_compositing;
 }
 
 bool PaintLayerCompositor::staleInCompositingMode() const {
   return m_compositing;
 }
 
 void PaintLayerCompositor::setCompositingModeEnabled(bool enable) {
   if (enable == m_compositing)
     return;
@@ skipping 96 matching lines @@
     // TODO(bbudge) Remove this check when trusted Pepper plugins are gone.
     if (localFrame->document()->isActive() &&
         !localFrame->contentLayoutItem().isNull())
       localFrame->contentLayoutItem()
           .compositor()
           ->updateIfNeededRecursiveInternal();
   }
 
   TRACE_EVENT0("blink", "PaintLayerCompositor::updateIfNeededRecursive");
 
-  ASSERT(!m_layoutView.needsLayout());
+  DCHECK(!m_layoutView.needsLayout());
 
   ScriptForbiddenScope forbidScript;
 
   // FIXME: enableCompositingModeIfNeeded can trigger a
   // CompositingUpdateRebuildTree, which asserts that it's not
   // InCompositingUpdate.
   enableCompositingModeIfNeeded();
 
   rootLayer()->updateDescendantDependentFlags();
 
   m_layoutView.commitPendingSelection();
 
   lifecycle().advanceTo(DocumentLifecycle::InCompositingUpdate);
   updateIfNeeded();
   lifecycle().advanceTo(DocumentLifecycle::CompositingClean);
 
   DocumentAnimations::updateAnimations(m_layoutView.document(),
                                        DocumentLifecycle::CompositingClean);
 
   m_layoutView.frameView()
       ->getScrollableArea()
       ->updateCompositorScrollAnimations();
   if (const FrameView::ScrollableAreaSet* animatingScrollableAreas =
           m_layoutView.frameView()->animatingScrollableAreas()) {
     for (ScrollableArea* scrollableArea : *animatingScrollableAreas)
       scrollableArea->updateCompositorScrollAnimations();
   }
 
 #if DCHECK_IS_ON()
-  ASSERT(lifecycle().state() == DocumentLifecycle::CompositingClean);
+  DCHECK_EQ(lifecycle().state(), DocumentLifecycle::CompositingClean);
   assertNoUnresolvedDirtyBits();
   for (Frame* child = m_layoutView.frameView()->frame().tree().firstChild();
        child; child = child->tree().nextSibling()) {
     if (!child->isLocalFrame())
       continue;
     LocalFrame* localFrame = toLocalFrame(child);
     if (localFrame->shouldThrottleRendering() ||
         localFrame->contentLayoutItem().isNull())
       continue;
     localFrame->contentLayoutItem().compositor()->assertNoUnresolvedDirtyBits();
   }
 #endif
 }
 
 void PaintLayerCompositor::setNeedsCompositingUpdate(
     CompositingUpdateType updateType) {
-  ASSERT(updateType != CompositingUpdateNone);
+  DCHECK_NE(updateType, CompositingUpdateNone);
   m_pendingUpdateType = std::max(m_pendingUpdateType, updateType);
   if (Page* page = this->page())
     page->animator().scheduleVisualUpdate(m_layoutView.frame());
   lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
 void PaintLayerCompositor::didLayout() {
   // FIXME: Technically we only need to do this when the FrameView's
   // isScrollable method would return a different value.
   m_rootShouldAlwaysCompositeDirty = true;
   enableCompositingModeIfNeeded();
 
   // FIXME: Rather than marking the entire LayoutView as dirty, we should
   // track which Layers moved during layout and only dirty those
   // specific Layers.
   rootLayer()->setNeedsCompositingInputsUpdate();
 }
 
 #if DCHECK_IS_ON()
 
 void PaintLayerCompositor::assertNoUnresolvedDirtyBits() {
-  ASSERT(m_pendingUpdateType == CompositingUpdateNone);
-  ASSERT(!m_rootShouldAlwaysCompositeDirty);
+  DCHECK_EQ(m_pendingUpdateType, CompositingUpdateNone);
+  DCHECK(!m_rootShouldAlwaysCompositeDirty);
 }
 
 #endif
 
 void PaintLayerCompositor::applyOverlayFullscreenVideoAdjustmentIfNeeded() {
   m_inOverlayFullscreenVideo = false;
   if (!m_rootContentLayer)
     return;
 
   bool isLocalRoot = m_layoutView.frame()->isLocalRoot();
@@ skipping 24 matching lines @@
 
   m_rootContentLayer->removeAllChildren();
   m_overflowControlsHostLayer->addChild(videoLayer);
   if (GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer())
     backgroundLayer->removeFromParent();
   m_inOverlayFullscreenVideo = true;
 }
 
 void PaintLayerCompositor::updateWithoutAcceleratedCompositing(
     CompositingUpdateType updateType) {
-  ASSERT(!hasAcceleratedCompositing());
+  DCHECK(!hasAcceleratedCompositing());
 
   if (updateType >= CompositingUpdateAfterCompositingInputChange)
     CompositingInputsUpdater(rootLayer()).update();
 
 #if DCHECK_IS_ON()
   CompositingInputsUpdater::assertNeedsCompositingInputsUpdateBitsCleared(
       rootLayer());
 #endif
 }
 
@@ skipping 154 matching lines @@
 bool PaintLayerCompositor::allocateOrClearCompositedLayerMapping(
     PaintLayer* layer,
     const CompositingStateTransitionType compositedLayerUpdate) {
   bool compositedLayerMappingChanged = false;
 
   // FIXME: It would be nice to directly use the layer's compositing reason,
   // but allocateOrClearCompositedLayerMapping also gets called without having
   // updated compositing requirements fully.
   switch (compositedLayerUpdate) {
     case AllocateOwnCompositedLayerMapping:
-      ASSERT(!layer->hasCompositedLayerMapping());
+      DCHECK(!layer->hasCompositedLayerMapping());
       setCompositingModeEnabled(true);
 
       // If we need to issue paint invalidations, do so before allocating the
       // compositedLayerMapping and clearing out the groupedMapping.
       paintInvalidationOnCompositingChange(layer);
 
       // If this layer was previously squashed, we need to remove its reference
       // to a groupedMapping right away, so that computing paint invalidation
       // rects will know the layer's correct compositingState.
       // FIXME: do we need to also remove the layer from it's location in the
@@ skipping 168 matching lines @@
 
 bool PaintLayerCompositor::scrollingLayerDidChange(PaintLayer* layer) {
   if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     return scrollingCoordinator->scrollableAreaScrollLayerDidChange(
         layer->getScrollableArea());
   return false;
 }
 
 std::unique_ptr<JSONObject> PaintLayerCompositor::layerTreeAsJSON(
     LayerTreeFlags flags) const {
-  ASSERT(lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean ||
+  DCHECK(lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean ||
          m_layoutView.frameView()->shouldThrottleRendering());
 
   // We skip dumping the scroll and clip layers to keep layerTreeAsText output
   // similar between platforms (unless we explicitly request dumping from the
   // root.
   GraphicsLayer* rootLayer = m_rootContentLayer.get();
   if (!rootLayer)
     rootLayer = rootGraphicsLayer();
 
   if (!rootLayer)
@@ skipping 276 matching lines @@
           graphicsLayer->contentsClippingMaskLayer()) {
     setTracksRasterInvalidationsRecursive(clippingMaskLayer,
                                           tracksPaintInvalidations);
   }
 }
 
 void PaintLayerCompositor::setTracksRasterInvalidations(
     bool tracksRasterInvalidations) {
 #if DCHECK_IS_ON()
   FrameView* view = m_layoutView.frameView();
-  ASSERT(lifecycle().state() == DocumentLifecycle::PaintClean ||
+  DCHECK(lifecycle().state() == DocumentLifecycle::PaintClean ||
          (view && view->shouldThrottleRendering()));
 #endif
 
   m_isTrackingRasterInvalidations = tracksRasterInvalidations;
   if (GraphicsLayer* rootLayer = rootGraphicsLayer())
     setTracksRasterInvalidationsRecursive(rootLayer, tracksRasterInvalidations);
 }
 
 bool PaintLayerCompositor::isTrackingRasterInvalidations() const {
   return m_isTrackingRasterInvalidations;
@@ skipping 101 matching lines @@
 
     // FIXME: with rootLayerScrolls, we probably don't even need
     // m_rootContentLayer?
     if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       // Need to clip to prevent transformed content showing outside this frame
       m_rootContentLayer->setMasksToBounds(true);
     }
   }
 
   if (shouldCreateOwnLayers && !m_overflowControlsHostLayer) {
-    ASSERT(!m_scrollLayer);
-    ASSERT(!m_containerLayer);
+    DCHECK(!m_scrollLayer);
+    DCHECK(!m_containerLayer);
 
     // Create a layer to host the clipping layer and the overflow controls
     // layers.
     m_overflowControlsHostLayer = GraphicsLayer::create(this);
 
     // Clip iframe's overflow controls layer.
     bool containerMasksToBounds = !m_layoutView.frame()->isLocalRoot();
     m_overflowControlsHostLayer->setMasksToBounds(containerMasksToBounds);
 
     // Create a clipping layer if this is an iframe or settings require to clip.
@@ skipping 52 matching lines @@
   if (m_layerForScrollCorner) {
     m_layerForScrollCorner = nullptr;
     m_layoutView.frameView()->setScrollCornerNeedsPaintInvalidation();
   }
 
   if (m_overflowControlsHostLayer) {
     m_overflowControlsHostLayer = nullptr;
     m_containerLayer = nullptr;
     m_scrollLayer = nullptr;
   }
-  ASSERT(!m_scrollLayer);
+  DCHECK(!m_scrollLayer);
   m_rootContentLayer = nullptr;
 }
 
 void PaintLayerCompositor::attachRootLayer() {
   // In Slimming Paint v2, PaintArtifactCompositor is responsible for the root
   // layer.
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
 
   if (m_layoutView.frame()->isLocalRoot()) {
@@ skipping 109 matching lines @@
   } else if (graphicsLayer == m_scrollLayer.get()) {
     name = "Frame Scrolling Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink