cc: Chromify Layer and LayerImpl classes.

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 "cc/layer_sorter.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 #include <vector>
@@ skipping 249 matching lines @@
 }
 
 void LayerSorter::CreateGraphNodes(LayerList::iterator first,
                                    LayerList::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++) {
     nodes_.push_back(GraphNode(*it));
     GraphNode& node = nodes_.at(nodes_.size() - 1);
-    RenderSurfaceImpl* render_surface = node.layer->renderSurface();
-    if (!node.layer->drawsContent() && !render_surface)
+    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() << ")";
 
     gfx::Transform draw_transform;
     float layer_width, layer_height;
     if (render_surface) {
       draw_transform = render_surface->draw_transform();
       layer_width = render_surface->content_rect().width();
       layer_height = render_surface->content_rect().height();
     } else {
-      draw_transform = node.layer->drawTransform();
-      layer_width = node.layer->contentBounds().width();
-      layer_height = node.layer->contentBounds().height();
+      draw_transform = node.layer->draw_transform();
+      layer_width = node.layer->content_bounds().width();
+      layer_height = node.layer->content_bounds().height();
     }
 
     node.shape = LayerShape(layer_width, layer_height, draw_transform);
 
     max_z = std::max(max_z, node.shape.transform_origin.z());
     min_z = std::min(min_z, node.shape.transform_origin.z());
   }
 
   z_range_ = fabsf(max_z - min_z);
 }
 
 void LayerSorter::CreateGraphEdges() {
   DVLOG(2) << "Edges:";
   // Fraction of the total zRange below which z differences
   // are not considered reliable.
   const float z_threshold_factor = 0.01f;
   float z_threshold = z_range_ * z_threshold_factor;
 
   for (size_t na = 0; na < nodes_.size(); na++) {
     GraphNode& node_a = nodes_[na];
-    if (!node_a.layer->drawsContent() && !node_a.layer->renderSurface())
+    if (!node_a.layer->DrawsContent() && !node_a.layer->render_surface())
       continue;
     for (size_t nb = na + 1; nb < nodes_.size(); nb++) {
       GraphNode& node_b = nodes_[nb];
-      if (!node_b.layer->drawsContent() && !node_b.layer->renderSurface())
+      if (!node_b.layer->DrawsContent() && !node_b.layer->render_surface())
         continue;
       float weight = 0.f;
       ABCompareResult overlap_result = CheckOverlap(&node_a.shape,
                                                     &node_b.shape,
                                                     z_threshold,
                                                     &weight);
       GraphNode* start_node = NULL;
       GraphNode* end_node = NULL;
       if (overlap_result == ABeforeB) {
         start_node = &node_a;
@@ skipping 136 matching lines @@
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
 
   nodes_.clear();
   edges_.clear();
   active_edges_.clear();
 }
 
 }  // namespace cc