cc: Fix capitalization style in chromified files.

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 170 matching lines @@
 
 LayerShape::LayerShape() {}
 
 LayerShape::LayerShape(float width,
                        float height,
                        const gfx::Transform& draw_transform) {
   gfx::QuadF layer_quad(gfx::RectF(0.f, 0.f, width, height));
 
   // Compute the projection of the layer quad onto the z = 0 plane.
 
-  gfx::PointF clippedQuad[8];
+  gfx::PointF clipped_quad[8];
   int num_vertices_in_clipped_quad;
   MathUtil::MapClippedQuad(draw_transform,
                            layer_quad,
-                           clippedQuad,
+                           clipped_quad,
                            num_vertices_in_clipped_quad);
 
   if (num_vertices_in_clipped_quad < 3) {
     projected_bounds = gfx::RectF();
     return;
   }
 
   projected_bounds =
-      MathUtil::ComputeEnclosingRectOfVertices(clippedQuad,
+      MathUtil::ComputeEnclosingRectOfVertices(clipped_quad,
                                                num_vertices_in_clipped_quad);
 
   // 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.
-  projected_quad.set_p1(clippedQuad[0]);
-  projected_quad.set_p2(clippedQuad[1]);
-  projected_quad.set_p3(clippedQuad[2]);
+  projected_quad.set_p1(clipped_quad[0]);
+  projected_quad.set_p2(clipped_quad[1]);
+  projected_quad.set_p3(clipped_quad[2]);
   if (num_vertices_in_clipped_quad >= 4) {
-    projected_quad.set_p4(clippedQuad[3]);
+    projected_quad.set_p4(clipped_quad[3]);
   } else {
     // This will be a degenerate quad that is actually a triangle.
-    projected_quad.set_p4(clippedQuad[2]);
+    projected_quad.set_p4(clipped_quad[2]);
   }
 
   // Compute the normal of the layer's plane.
   bool clipped = false;
   gfx::Point3F c1 =
       MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 0.f, 0.f), &clipped);
   gfx::Point3F c2 =
       MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 1.f, 0.f), &clipped);
   gfx::Point3F c3 =
       MathUtil::MapPoint(draw_transform, gfx::Point3F(1.f, 0.f, 0.f), &clipped);
@@ skipping 61 matching lines @@
 
     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
+  // Fraction of the total z_range 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->render_surface())
       continue;
     for (size_t nb = na + 1; nb < nodes_.size(); nb++) {
       GraphNode& node_b = nodes_[nb];
@@ skipping 147 matching lines @@
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
 
   nodes_.clear();
   edges_.clear();
   active_edges_.clear();
 }
 
 }  // namespace cc