cc: Switch to Chromium DCHECKs and LOGs

cc/LayerChromium.cpp

 // Copyright 2010 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"
 
 #if USE(ACCELERATED_COMPOSITING)
 #include "LayerChromium.h"
 
 #include "CCActiveAnimation.h"
@@ skipping 60 matching lines @@
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
 }
 
 LayerChromium::~LayerChromium()
 {
     // Our parent should be holding a reference to us so there should be no
     // way for us to be destroyed while we still have a parent.
-    ASSERT(!parent());
+    DCHECK(!parent());
 
     // Remove the parent reference from all children.
     removeAllChildren();
 }
 
 void LayerChromium::setUseLCDText(bool useLCDText)
 {
     m_useLCDText = useLCDText;
 }
 
@@ skipping 27 matching lines @@
 {
     float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
     float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
     FloatRect contentRect(layerRect.x, layerRect.y, layerRect.width, layerRect.height);
     contentRect.scale(widthScale, heightScale);
     return enclosingIntRect(contentRect);
 }
 
 void LayerChromium::setParent(LayerChromium* layer)
 {
-    ASSERT(!layer || !layer->hasAncestor(this));
+    DCHECK(!layer || !layer->hasAncestor(this));
     m_parent = layer;
     setLayerTreeHost(m_parent ? m_parent->layerTreeHost() : 0);
 }
 
 bool LayerChromium::hasAncestor(LayerChromium* ancestor) const
 {
     for (LayerChromium* layer = parent(); layer; layer = layer->parent()) {
         if (layer == ancestor)
             return true;
     }
@@ skipping 40 matching lines @@
 void LayerChromium::replaceChild(LayerChromium* reference, scoped_refptr<LayerChromium> newLayer)
 {
     ASSERT_ARG(reference, reference);
     ASSERT_ARG(reference, reference->parent() == this);
 
     if (reference == newLayer)
         return;
 
     int referenceIndex = indexOfChild(reference);
     if (referenceIndex == -1) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return;
     }
 
     reference->removeFromParent();
 
     if (newLayer) {
         newLayer->removeFromParent();
         insertChild(newLayer, referenceIndex);
     }
 }
@@ skipping 27 matching lines @@
     LayerChromium* layer = this;
     while (layer->parent())
         layer = layer->parent();
     return layer;
 }
 
 void LayerChromium::removeAllChildren()
 {
     while (m_children.size()) {
         LayerChromium* layer = m_children[0].get();
-        ASSERT(layer->parent());
+        DCHECK(layer->parent());
         layer->removeFromParent();
     }
 }
 
 void LayerChromium::setChildren(const LayerList& children)
 {
     if (children == m_children)
         return;
 
     removeAllChildren();
@@ skipping 399 matching lines @@
 
     if (boundsContainPageScale == m_boundsContainPageScale)
         return;
 
     m_boundsContainPageScale = boundsContainPageScale;
     setNeedsDisplay();
 }
 
 void LayerChromium::createRenderSurface()
 {
-    ASSERT(!m_renderSurface);
+    DCHECK(!m_renderSurface);
     m_renderSurface = adoptPtr(new RenderSurfaceChromium(this));
     setRenderTarget(this);
 }
 
 bool LayerChromium::descendantDrawsContent()
 {
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i]->drawsContent() || m_children[i]->descendantDrawsContent())
             return true;
     }
@@ skipping 121 matching lines @@
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<LayerChromium> >::iterator, std::vector<scoped_refptr<LayerChromium> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort LayerChromiums.
 }
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)