cc: Switch to Chromium DCHECKs LOGs

cc/layer_tree_host_common.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCLayerTreeHostCommon.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerIterator.h"
@@ skipping 93 matching lines @@
 
 template<typename LayerType>
 static inline bool layerClipsSubtree(LayerType* layer)
 {
     return layer->masksToBounds() || layer->maskLayer();
 }
 
 template<typename LayerType>
 static IntRect calculateVisibleContentRect(LayerType* layer)
 {
-    ASSERT(layer->renderTarget());
+    DCHECK(layer->renderTarget());
 
     // Nothing is visible if the layer bounds are empty.
     if (!layer->drawsContent() || layer->contentBounds().isEmpty() || layer->drawableContentRect().isEmpty())
         return IntRect();
 
     IntRect targetSurfaceClipRect;
 
     // First, compute visible bounds in target surface space.
     if (layer->renderTarget()->renderSurface()->clipRect().isEmpty())
         targetSurfaceClipRect = layer->drawableContentRect();
@@ skipping 54 matching lines @@
     //
     // Note, if the layer should not have been drawn due to being fully transparent,
     // we would have skipped the entire subtree and never made it into this function,
     // so it is safe to omit this check here.
 
     if (!layer->drawsContent() || layer->bounds().isEmpty())
         return true;
 
     LayerType* backfaceTestLayer = layer;
     if (layer->useParentBackfaceVisibility()) {
-        ASSERT(layer->parent());
-        ASSERT(!layer->parent()->useParentBackfaceVisibility());
+        DCHECK(layer->parent());
+        DCHECK(!layer->parent()->useParentBackfaceVisibility());
         backfaceTestLayer = layer->parent();
     }
 
     // The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is known to be facing the screen.
     if (!backfaceTestLayer->doubleSided() && transformToScreenIsKnown(backfaceTestLayer) && isLayerBackFaceVisible(backfaceTestLayer))
         return true;
 
     return false;
 }
 
@@ skipping 145 matching lines @@
 // Should be called just before the recursive calculateDrawTransformsInternal().
 template<typename LayerType, typename LayerList>
 void setupRootLayerAndSurfaceForRecursion(LayerType* rootLayer, LayerList& renderSurfaceLayerList, const IntSize& deviceViewportSize)
 {
     if (!rootLayer->renderSurface())
         rootLayer->createRenderSurface();
 
     rootLayer->renderSurface()->setContentRect(IntRect(IntPoint::zero(), deviceViewportSize));
     rootLayer->renderSurface()->clearLayerLists();
 
-    ASSERT(renderSurfaceLayerList.empty());
+    DCHECK(renderSurfaceLayerList.empty());
     renderSurfaceLayerList.push_back(rootLayer);
 }
 
 // Recursively walks the layer tree starting at the given node and computes all the
 // necessary transformations, clipRects, render surfaces, etc.
 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
 static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix,
     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
     const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
@@ skipping 224 matching lines @@
     } else {
         layer->setDrawTransform(drawTransform);
         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
         sublayerMatrix = combinedTransform;
 
         layer->setDrawOpacity(drawOpacity);
         layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
 
         if (layer != rootLayer) {
-            ASSERT(layer->parent());
+            DCHECK(layer->parent());
             layer->clearRenderSurface();
 
             // Layers without renderSurfaces directly inherit the ancestor's clip status.
             subtreeShouldBeClipped = ancestorClipsSubtree;
             if (ancestorClipsSubtree)
                 clipRectForSubtree = clipRectFromAncestor;
 
             // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
             layer->setRenderTarget(layer->parent()->renderTarget());
         } else {
             // FIXME: This root layer special case code should eventually go away. https://bugs.webkit.org/show_bug.cgi?id=92290
-            ASSERT(!layer->parent());
-            ASSERT(layer->renderSurface());
-            ASSERT(ancestorClipsSubtree);
+            DCHECK(!layer->parent());
+            DCHECK(layer->renderSurface());
+            DCHECK(ancestorClipsSubtree);
             layer->renderSurface()->setClipRect(clipRectFromAncestor);
             subtreeShouldBeClipped = false;
         }
     }
 
     IntRect rectInTargetSpace = enclosingIntRect(CCMathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
@@ skipping 103 matching lines @@
         if (!layer->renderSurface()->layerList().size()) {
             // FIXME: Originally we asserted that this layer was already at the end of the
             //        list, and only needed to remove that layer. For now, we remove the
             //        entire subtree of surfaces to fix a crash bug. The root cause is
             //        https://bugs.webkit.org/show_bug.cgi?id=74147 and we should be able
             //        to put the original assert after fixing that.
             while (renderSurfaceLayerList.back() != layer) {
                 renderSurfaceLayerList.back()->clearRenderSurface();
                 renderSurfaceLayerList.pop_back();
             }
-            ASSERT(renderSurfaceLayerList.back() == layer);
+            DCHECK(renderSurfaceLayerList.back() == layer);
             renderSurfaceLayerList.pop_back();
             layer->clearRenderSurface();
             return;
         }
     }
 
     // If neither this layer nor any of its children were added, early out.
     if (sortingStartIndex == descendants.size())
         return;
 
@@ skipping 105 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the viewportPoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 } // namespace cc