Revert "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 <limits>
-
-#include "base/logging.h"
 #include "CCMathUtil.h"
 #include "CCRenderSurface.h"
+#include <limits.h>
 #include <public/WebTransformationMatrix.h>
 #include <wtf/Deque.h>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
-#define SHOW_DEBUG_LOG 0 && !defined(NDEBUG)
+#define LOG_CHANNEL_PREFIX Log
+#define SHOW_DEBUG_LOG 0
+
+#if !defined( NDEBUG )
+#if SHOW_DEBUG_LOG
+static WTFLogChannel LogCCLayerSorter = { 0x00000000, "", WTFLogChannelOn };
+#else
+static WTFLogChannel LogCCLayerSorter = { 0x00000000, "", WTFLogChannelOff };
+#endif
+#endif
 
 namespace cc {
 
 inline static float perpProduct(const FloatSize& u, const FloatSize& v)
 {
     return u.width() * v.height() - u.height() * v.width();
 }
 
 // Tests if two edges defined by their endpoints (a,b) and (c,d) intersect. Returns true and the
 // point of intersection if they do and false otherwise.
@@ skipping 178 matching lines @@
         return 0;
 
     // The intersection point would be given by:
     // p + (n / d) * u  but since we are only interested in the 
     // z coordinate and p's z coord is zero, all we need is the value of n/d.
     return n / d;
 }
 
 void CCLayerSorter::createGraphNodes(LayerList::iterator first, LayerList::iterator last)
 {
-#if SHOW_DEBUG_LOG
-    DLOG(INFO) << "CCLayerSorter: Creating graph nodes:\n";
+#if !defined( NDEBUG )
+    LOG(CCLayerSorter, "Creating graph nodes:\n");
 #endif
     float minZ = FLT_MAX;
     float maxZ = -FLT_MAX;
     for (LayerList::const_iterator it = first; it < last; it++) {
         m_nodes.append(GraphNode(*it));
         GraphNode& node = m_nodes.at(m_nodes.size() - 1);
         CCRenderSurface* renderSurface = node.layer->renderSurface();
         if (!node.layer->drawsContent() && !renderSurface)
             continue;
 
-#if SHOW_DEBUG_LOG
-        DLOG(INFO) << "CCLayerSorter: Layer " << node.layer->id() << " (" << node.layer->bounds().width() << " x " << node.layer->bounds().height() << ")\n";
+#if !defined( NDEBUG )
+        LOG(CCLayerSorter, "Layer %d (%d x %d)\n", node.layer->id(), node.layer->bounds().width(), node.layer->bounds().height());
 #endif
 
         WebTransformationMatrix drawTransform;
         float layerWidth, layerHeight;
         if (renderSurface) {
             drawTransform = renderSurface->drawTransform();
             layerWidth = renderSurface->contentRect().width();
             layerHeight = renderSurface->contentRect().height();
         } else {
             drawTransform = node.layer->drawTransform();
             layerWidth = node.layer->contentBounds().width();
             layerHeight = node.layer->contentBounds().height();
         }
 
         node.shape = LayerShape(layerWidth, layerHeight, drawTransform);
 
         maxZ = max(maxZ, node.shape.transformOrigin.z());
         minZ = min(minZ, node.shape.transformOrigin.z());
     }
 
     m_zRange = fabsf(maxZ - minZ);
 }
 
 void CCLayerSorter::createGraphEdges()
 {
-#if SHOW_DEBUG_LOG
-    DLOG(INFO) << "CCLayerSorter: Edges:\n";
+#if !defined( NDEBUG )
+    LOG(CCLayerSorter, "Edges:\n");
 #endif
     // Fraction of the total zRange below which z differences
     // are not considered reliable.
     const float zThresholdFactor = 0.01f;
     float zThreshold = m_zRange * zThresholdFactor;
 
     for (unsigned na = 0; na < m_nodes.size(); na++) {
         GraphNode& nodeA = m_nodes[na];
         if (!nodeA.layer->drawsContent() && !nodeA.layer->renderSurface())
             continue;
         for (unsigned nb = na + 1; nb < m_nodes.size(); nb++) {
             GraphNode& nodeB = m_nodes[nb];
             if (!nodeB.layer->drawsContent() && !nodeB.layer->renderSurface())
                 continue;
             float weight = 0;
             ABCompareResult overlapResult = checkOverlap(&nodeA.shape, &nodeB.shape, zThreshold, weight);
             GraphNode* startNode = 0;
             GraphNode* endNode = 0;
             if (overlapResult == ABeforeB) {
                 startNode = &nodeA;
                 endNode = &nodeB;
             } else if (overlapResult == BBeforeA) {
                 startNode = &nodeB;
                 endNode = &nodeA;
             }
 
             if (startNode) {
-#if SHOW_DEBUG_LOG
-                DLOG(INFO) << "CCLayerSorter: " << startNode->layer->id() << " -> " << endNode->layer->id() << "\n";
+#if !defined( NDEBUG )
+                LOG(CCLayerSorter, "%d -> %d\n", startNode->layer->id(), endNode->layer->id());
 #endif
                 m_edges.append(GraphEdge(startNode, endNode, weight));
             }
         }
     }
 
     for (unsigned i = 0; i < m_edges.size(); i++) {
         GraphEdge& edge = m_edges[i];
         m_activeEdges.add(&edge, &edge);
         edge.from->outgoing.append(&edge);
         edge.to->incoming.append(&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, Vector<GraphEdge*>& list)
 {
     size_t edgeIndex = list.find(edge);
-    DCHECK(edgeIndex != notFound);
+    ASSERT(edgeIndex != notFound);
     if (list.size() == 1) {
-        DCHECK(!edgeIndex);
+        ASSERT(!edgeIndex);
         list.clear();
         return;
     }
     if (edgeIndex != list.size() - 1)
         list[edgeIndex] = list[list.size() - 1];
 
     list.removeLast();
 }
 
 // Sorts the given list of layers such that they can be painted in a back-to-front
@@ skipping 10 matching lines @@
 // coordinate. The layer with the lower Z coordinate (farther from the eye) needs to be rendered
 // first.
 //
 // If the layer projections don't intersect, then no edges (dependencies) are created
 // between them in the graph. HOWEVER, in this case we still need to preserve the ordering
 // of the original list of layers, since that list should already have proper z-index
 // ordering of layers.
 //
 void CCLayerSorter::sort(LayerList::iterator first, LayerList::iterator last)
 {
-#if SHOW_DEBUG_LOG
-    DLOG(INFO) << "CCLayerSorter: Sorting start ----\n";
+#if !defined( NDEBUG )
+    LOG(CCLayerSorter, "Sorting start ----\n");
 #endif
     createGraphNodes(first, last);
 
     createGraphEdges();
 
     Vector<GraphNode*> sortedList;
     Deque<GraphNode*> noIncomingEdgeNodeList;
 
     // Find all the nodes that don't have incoming edges.
     for (NodeList::iterator la = m_nodes.begin(); la < m_nodes.end(); la++) {
         if (!la->incoming.size())
             noIncomingEdgeNodeList.append(la);
     }
 
-#if SHOW_DEBUG_LOG
-    DLOG(INFO) << "CCLayerSorter: Sorted list: ";
+#if !defined( NDEBUG )
+    LOG(CCLayerSorter, "Sorted list: ");
 #endif
     while (m_activeEdges.size() || noIncomingEdgeNodeList.size()) {
         while (noIncomingEdgeNodeList.size()) {
 
             // It is necessary to preserve the existing ordering of layers, when there are
             // no explicit dependencies (because this existing ordering has correct
             // z-index/layout ordering). To preserve this ordering, we process Nodes in
             // the same order that they were added to the list.
             GraphNode* fromNode = noIncomingEdgeNodeList.takeFirst();
 
             // Add it to the final list.
             sortedList.append(fromNode);
 
-#if SHOW_DEBUG_LOG
-            DLOG(INFO) << fromNode->layer->id() << ", ";
+#if !defined( NDEBUG )
+            LOG(CCLayerSorter, "%d, ", fromNode->layer->id());
 #endif
 
             // Remove all its outgoing edges from the graph.
             for (unsigned i = 0; i < fromNode->outgoing.size(); i++) {
                 GraphEdge* outgoingEdge = fromNode->outgoing[i];
 
                 m_activeEdges.remove(outgoingEdge);
                 removeEdgeFromList(outgoingEdge, outgoingEdge->to->incoming);
                 outgoingEdge->to->incomingEdgeWeight -= outgoingEdge->weight;
 
@@ skipping 12 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];
             }
         }
-        DCHECK(nextNode);
+        ASSERT(nextNode);
         // Remove all its incoming edges.
         for (unsigned e = 0; e < nextNode->incoming.size(); e++) {
             GraphEdge* incomingEdge = nextNode->incoming[e];
 
             m_activeEdges.remove(incomingEdge);
             removeEdgeFromList(incomingEdge, incomingEdge->from->outgoing);
         }
         nextNode->incoming.clear();
         nextNode->incomingEdgeWeight = 0;
         noIncomingEdgeNodeList.append(nextNode);
-#if SHOW_DEBUG_LOG
-        DLOG(INFO) << "Breaking cycle by cleaning up incoming edges from " << nextNode->layer->id() << " (weight = " << minIncomingEdgeWeight<< ")\n";
+#if !defined( NDEBUG )
+        LOG(CCLayerSorter, "Breaking cycle by cleaning up incoming edges from %d (weight = %f)\n", nextNode->layer->id(), minIncomingEdgeWeight);
 #endif
     }
 
     // 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;
 
-#if SHOW_DEBUG_LOG
-    DLOG(INFO) << "CCLayerSorter: Sorting end ----\n";
+#if !defined( NDEBUG )
+    LOG(CCLayerSorter, "Sorting end ----\n");
 #endif
 
     m_nodes.clear();
     m_edges.clear();
     m_activeEdges.clear();
 }
 
 }