cc: Consolidate LayerList types.

cc/trees/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 "cc/trees/layer_sorter.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 #include <vector>
@@ skipping 241 matching lines @@
   // invisible and hence returning zero is fine.
   if (!d)
     return 0.f;
 
   // 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 LayerSorter::CreateGraphNodes(LayerList::iterator first,
-                                   LayerList::iterator last) {
+void LayerSorter::CreateGraphNodes(LayerImplList::iterator first,
+                                   LayerImplList::iterator last) {
   DVLOG(2) << "Creating graph nodes:";
   float min_z = FLT_MAX;
   float max_z = -FLT_MAX;
-  for (LayerList::const_iterator it = first; it < last; it++) {
+  for (LayerImplList::const_iterator it = first; it < last; it++) {
     nodes_.push_back(GraphNode(*it));
     GraphNode& node = nodes_.at(nodes_.size() - 1);
     RenderSurfaceImpl* render_surface = node.layer->render_surface();
     if (!node.layer->DrawsContent() && !render_surface)
       continue;
 
     DVLOG(2) << "Layer " << node.layer->id() <<
         " (" << node.layer->bounds().width() <<
         " x " << node.layer->bounds().height() << ")";
 
@@ skipping 88 matching lines @@
 // 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 LayerSorter::Sort(LayerList::iterator first, LayerList::iterator last) {
+void LayerSorter::Sort(LayerImplList::iterator first,
+                       LayerImplList::iterator last) {
   DVLOG(2) << "Sorting start ----";
   CreateGraphNodes(first, last);
 
   CreateGraphEdges();
 
   std::vector<GraphNode*> sorted_list;
   std::deque<GraphNode*> no_incoming_edge_node_list;
 
   // Find all the nodes that don't have incoming edges.
   for (NodeList::iterator la = nodes_.begin(); la < nodes_.end(); la++) {
@@ skipping 60 matching lines @@
     no_incoming_edge_node_list.push_back(next_node);
     DVLOG(2) << "Breaking cycle by cleaning up incoming edges from " <<
         next_node->layer->id() <<
         " (weight = " << min_incoming_edge_weight << ")";
   }
 
   // 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++)
+  for (LayerImplList::iterator it = first; it < last; it++)
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
 
   nodes_.clear();
   edges_.clear();
   active_edges_.clear();
 }
 
 }  // namespace cc