cc: Switch to Chromium DCHECKs LOGs

cc/layer_sorter.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 "CCLayerSorter.h"
 
 #include "CCMathUtil.h"
 #include "CCRenderSurface.h"
@@ skipping 278 matching lines @@
         edge.to->incoming.push_back(&edge);
         edge.to->incomingEdgeWeight += edge.weight;
     }
 }
 
 // Finds and removes an edge from the list by doing a swap with the
 // last element of the list.
 void CCLayerSorter::removeEdgeFromList(GraphEdge* edge, std::vector<GraphEdge*>& list)
 {
     std::vector<GraphEdge*>::iterator iter = std::find(list.begin(), list.end(), edge);
-    ASSERT(iter != list.end());
+    DCHECK(iter != list.end());
     list.erase(iter);
 }
 
 // Sorts the given list of layers such that they can be painted in a back-to-front
 // order. Sorting produces correct results for non-intersecting layers that don't have
 // cyclical order dependencies. Cycles and intersections are broken (somewhat) aribtrarily.
 // Sorting of layers is done via a topological sort of a directed graph whose nodes are
 // the layers themselves. An edge from node A to node B signifies that layer A needs to
 // be drawn before layer B. If A and B have no dependency between each other, then we
 // preserve the ordering of those layers as they were in the original list.
@@ skipping 64 matching lines @@
         // nodes that have zero-weight incoming edges i.e. layers that are being
         // occluded by a layer that intersects them.
         float minIncomingEdgeWeight = FLT_MAX;
         GraphNode* nextNode = 0;
         for (unsigned i = 0; i < m_nodes.size(); i++) {
             if (m_nodes[i].incoming.size() && m_nodes[i].incomingEdgeWeight < minIncomingEdgeWeight) {
                 minIncomingEdgeWeight = m_nodes[i].incomingEdgeWeight;
                 nextNode = &m_nodes[i];
             }
         }
-        ASSERT(nextNode);
+        DCHECK(nextNode);
         // Remove all its incoming edges.
         for (unsigned e = 0; e < nextNode->incoming.size(); e++) {
             GraphEdge* incomingEdge = nextNode->incoming[e];
 
             m_activeEdges.erase(incomingEdge);
             removeEdgeFromList(incomingEdge, incomingEdge->from->outgoing);
         }
         nextNode->incoming.clear();
         nextNode->incomingEdgeWeight = 0;
         noIncomingEdgeNodeList.push_back(nextNode);
         DVLOG(2) << "Breaking cycle by cleaning up incoming edges from " << nextNode->layer->id() << " (weight = " << minIncomingEdgeWeight << ")";
     }
 
     // Note: The original elements of the list are in no danger of having their ref count go to zero
     // here as they are all nodes of the layer hierarchy and are kept alive by their parent nodes.
     int count = 0;
     for (LayerList::iterator it = first; it < last; it++)
         *it = sortedList[count++]->layer;
 
     DVLOG(2) << "Sorting end ----";
 
     m_nodes.clear();
     m_edges.clear();
     m_activeEdges.clear();
 }
 
 }