cc: Rename cc classes and members to match filenames

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"
 #include <limits.h>
 #include <public/WebTransformationMatrix.h>
 #include <deque>
 #include <vector>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 #define LOG_CHANNEL_PREFIX Log
 #define SHOW_DEBUG_LOG 0
 
 #if !defined( NDEBUG )
 #if SHOW_DEBUG_LOG
-static WTFLogChannel LogCCLayerSorter = { 0x00000000, "", WTFLogChannelOn };
+static WTFLogChannel LogLayerSorter = { 0x00000000, "", WTFLogChannelOn };
 #else
-static WTFLogChannel LogCCLayerSorter = { 0x00000000, "", WTFLogChannelOff };
+static WTFLogChannel LogLayerSorter = { 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();
 }
 
@@ skipping 19 matching lines @@
 
     float t = perpProduct(u, w) / denom;
     if (t < 0 || t > 1)
         return false;
 
     u.scale(s);
     r = a + u;
     return true;
 }
 
-GraphNode::GraphNode(CCLayerImpl* cclayer)
-    : layer(cclayer)
+GraphNode::GraphNode(LayerImpl* layerImpl)
+    : layer(layerImpl)
     , incomingEdgeWeight(0)
 {
 }
 
 GraphNode::~GraphNode()
 {
 }
 
-CCLayerSorter::CCLayerSorter()
+LayerSorter::LayerSorter()
     : m_zRange(0)
 {
 }
 
-CCLayerSorter::~CCLayerSorter()
+LayerSorter::~LayerSorter()
 {
 }
 
 // Checks whether layer "a" draws on top of layer "b". The weight value returned is an indication of
 // the maximum z-depth difference between the layers or zero if the layers are found to be intesecting
 // (some features are in front and some are behind).
-CCLayerSorter::ABCompareResult CCLayerSorter::checkOverlap(LayerShape* a, LayerShape* b, float zThreshold, float& weight)
+LayerSorter::ABCompareResult LayerSorter::checkOverlap(LayerShape* a, LayerShape* b, float zThreshold, float& weight)
 {
     weight = 0;
 
     // Early out if the projected bounds don't overlap.
     if (!a->projectedBounds.intersects(b->projectedBounds))
         return None;
 
     FloatPoint aPoints[4] = {a->projectedQuad.p1(), a->projectedQuad.p2(), a->projectedQuad.p3(), a->projectedQuad.p4() };
     FloatPoint bPoints[4] = {b->projectedQuad.p1(), b->projectedQuad.p2(), b->projectedQuad.p3(), b->projectedQuad.p4() };
 
@@ skipping 58 matching lines @@
 }
 
 LayerShape::LayerShape(float width, float height, const WebTransformationMatrix& drawTransform)
 {
     FloatQuad layerQuad(FloatRect(0, 0, width, height));
 
     // Compute the projection of the layer quad onto the z = 0 plane.
 
     FloatPoint clippedQuad[8];
     int numVerticesInClippedQuad;
-    CCMathUtil::mapClippedQuad(drawTransform, layerQuad, clippedQuad, numVerticesInClippedQuad);
+    MathUtil::mapClippedQuad(drawTransform, layerQuad, clippedQuad, numVerticesInClippedQuad);
 
     if (numVerticesInClippedQuad < 3) {
         projectedBounds = FloatRect();
         return;
     }
 
-    projectedBounds = CCMathUtil::computeEnclosingRectOfVertices(clippedQuad, numVerticesInClippedQuad);
+    projectedBounds = MathUtil::computeEnclosingRectOfVertices(clippedQuad, numVerticesInClippedQuad);
 
     // NOTE: it will require very significant refactoring and overhead to deal with
     // generalized polygons or multiple quads per layer here. For the sake of layer
     // sorting it is equally correct to take a subsection of the polygon that can be made
     // into a quad. This will only be incorrect in the case of intersecting layers, which
     // are not supported yet anyway.
     projectedQuad.setP1(clippedQuad[0]);
     projectedQuad.setP2(clippedQuad[1]);
     projectedQuad.setP3(clippedQuad[2]);
     if (numVerticesInClippedQuad >= 4)
         projectedQuad.setP4(clippedQuad[3]);
     else
         projectedQuad.setP4(clippedQuad[2]); // this will be a degenerate quad that is actually a triangle.
 
     // Compute the normal of the layer's plane.
     bool clipped = false;
-    FloatPoint3D c1 = CCMathUtil::mapPoint(drawTransform, FloatPoint3D(0, 0, 0), clipped);
-    FloatPoint3D c2 = CCMathUtil::mapPoint(drawTransform, FloatPoint3D(0, 1, 0), clipped);
-    FloatPoint3D c3 = CCMathUtil::mapPoint(drawTransform, FloatPoint3D(1, 0, 0), clipped);
+    FloatPoint3D c1 = MathUtil::mapPoint(drawTransform, FloatPoint3D(0, 0, 0), clipped);
+    FloatPoint3D c2 = MathUtil::mapPoint(drawTransform, FloatPoint3D(0, 1, 0), clipped);
+    FloatPoint3D c3 = MathUtil::mapPoint(drawTransform, FloatPoint3D(1, 0, 0), clipped);
     // FIXME: Deal with clipping.
     FloatPoint3D c12 = c2 - c1;
     FloatPoint3D c13 = c3 - c1;
     layerNormal = c13.cross(c12);
 
     transformOrigin = c1;
 }
 
 // Returns the Z coordinate of a point on the layer that projects
 // to point p which lies on the z = 0 plane. It does it by computing the
@@ skipping 11 matching lines @@
     // invisible and hence returning zero is fine.
     if (!d)
         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)
+void LayerSorter::createGraphNodes(LayerList::iterator first, LayerList::iterator last)
 {
 #if !defined( NDEBUG )
-    LOG(CCLayerSorter, "Creating graph nodes:\n");
+    LOG(LayerSorter, "Creating graph nodes:\n");
 #endif
     float minZ = FLT_MAX;
     float maxZ = -FLT_MAX;
     for (LayerList::const_iterator it = first; it < last; it++) {
         m_nodes.push_back(GraphNode(*it));
         GraphNode& node = m_nodes.at(m_nodes.size() - 1);
-        CCRenderSurface* renderSurface = node.layer->renderSurface();
+        RenderSurfaceImpl* renderSurface = node.layer->renderSurface();
         if (!node.layer->drawsContent() && !renderSurface)
             continue;
 
 #if !defined( NDEBUG )
-        LOG(CCLayerSorter, "Layer %d (%d x %d)\n", node.layer->id(), node.layer->bounds().width(), node.layer->bounds().height());
+        LOG(LayerSorter, "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()
+void LayerSorter::createGraphEdges()
 {
 #if !defined( NDEBUG )
-    LOG(CCLayerSorter, "Edges:\n");
+    LOG(LayerSorter, "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 !defined( NDEBUG )
-                LOG(CCLayerSorter, "%d -> %d\n", startNode->layer->id(), endNode->layer->id());
+                LOG(LayerSorter, "%d -> %d\n", startNode->layer->id(), endNode->layer->id());
 #endif
                 m_edges.push_back(GraphEdge(startNode, endNode, weight));
             }
         }
     }
 
     for (unsigned i = 0; i < m_edges.size(); i++) {
         GraphEdge& edge = m_edges[i];
         m_activeEdges[&edge] = &edge;
         edge.from->outgoing.push_back(&edge);
         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)
+void LayerSorter::removeEdgeFromList(GraphEdge* edge, std::vector<GraphEdge*>& list)
 {
     std::vector<GraphEdge*>::iterator iter = std::find(list.begin(), list.end(), edge);
     ASSERT(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.
 //
 // The draw order between two layers is determined by projecting the two triangles making
 // up each layer quad to the Z = 0 plane, finding points of intersection between the triangles
 // and backprojecting those points to the plane of the layer to determine the corresponding Z
 // 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)
+void LayerSorter::sort(LayerList::iterator first, LayerList::iterator last)
 {
 #if !defined( NDEBUG )
-    LOG(CCLayerSorter, "Sorting start ----\n");
+    LOG(LayerSorter, "Sorting start ----\n");
 #endif
     createGraphNodes(first, last);
 
     createGraphEdges();
 
     std::vector<GraphNode*> sortedList;
     std::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.push_back(&(*la));
     }
 
 #if !defined( NDEBUG )
-    LOG(CCLayerSorter, "Sorted list: ");
+    LOG(LayerSorter, "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.front();
             noIncomingEdgeNodeList.pop_front();
 
             // Add it to the final list.
             sortedList.push_back(fromNode);
 
 #if !defined( NDEBUG )
-            LOG(CCLayerSorter, "%d, ", fromNode->layer->id());
+            LOG(LayerSorter, "%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.erase(outgoingEdge);
                 removeEdgeFromList(outgoingEdge, outgoingEdge->to->incoming);
                 outgoingEdge->to->incomingEdgeWeight -= outgoingEdge->weight;
 
@@ skipping 24 matching lines @@
         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);
 #if !defined( NDEBUG )
-        LOG(CCLayerSorter, "Breaking cycle by cleaning up incoming edges from %d (weight = %f)\n", nextNode->layer->id(), minIncomingEdgeWeight);
+        LOG(LayerSorter, "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 !defined( NDEBUG )
-    LOG(CCLayerSorter, "Sorting end ----\n");
+    LOG(LayerSorter, "Sorting end ----\n");
 #endif
 
     m_nodes.clear();
     m_edges.clear();
     m_activeEdges.clear();
 }
 
 }