cc: Fix capitalization style in chromified files.

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
@@ skipping 235 matching lines @@
     affected_area_in_target.Intersect(
         contributing_layer->render_surface()->clip_rect());
   }
   if (affected_area_in_target.IsEmpty())
     return;
 
   int outset_top, outset_right, outset_bottom, outset_left;
   contributing_layer->background_filters().getOutsets(
       outset_top, outset_right, outset_bottom, outset_left);
 
-  // The filter can move pixels from outside of the clip, so allow affectedArea
+  // The filter can move pixels from outside of the clip, so allow affected_area
   // to expand outside the clip.
   affected_area_in_target.Inset(
       -outset_left, -outset_top, -outset_right, -outset_bottom);
 
   gfx::Rect FilterOutsetsInTarget(-outset_left,
                                   -outset_top,
                                   outset_left + outset_right,
                                   outset_top + outset_bottom);
 
   Region affected_occlusion = IntersectRegions(*occlusion_from_inside_target,
@@ skipping 152 matching lines @@
       layer->draw_transform(), gfx::QuadF(opaque_contents.bounds()), &clipped);
   // FIXME: Find a rect interior to each transformed quad.
   if (clipped || !visible_transformed_quad.IsRectilinear())
     return;
 
   gfx::Rect clip_rect_in_target = gfx::IntersectRects(
       layer->render_target()->render_surface()->content_rect(),
       ScreenSpaceClipRectInTargetSurface(
           layer->render_target()->render_surface(), screen_space_clip_rect_));
 
-  for (Region::Iterator opaqueContentRects(opaque_contents);
-       opaqueContentRects.has_rect();
-       opaqueContentRects.next()) {
+  for (Region::Iterator opaque_content_rects(opaque_contents);
+       opaque_content_rects.has_rect();
+       opaque_content_rects.next()) {
     gfx::QuadF transformed_quad = MathUtil::MapQuad(
         layer->draw_transform(),
-        gfx::QuadF(opaqueContentRects.rect()),
+        gfx::QuadF(opaque_content_rects.rect()),
         &clipped);
     gfx::Rect transformed_rect =
         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.width() < minimum_tracking_size_.width() &&
         transformed_rect.height() < minimum_tracking_size_.height())
       continue;
     stack_.back().occlusion_from_inside_target.Union(transformed_rect);
 
     if (!occluding_screen_space_rects_)
       continue;
 
     // Save the occluding area in screen space for debug visualization.
     gfx::QuadF screen_space_quad = MathUtil::MapQuad(
         layer->render_target()->render_surface()->screen_space_transform(),
         gfx::QuadF(transformed_rect), &clipped);
     // TODO(danakj): Store the quad in the debug info instead of the bounding
     // box.
     gfx::Rect screen_space_rect =
         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
     occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 
   if (!non_occluding_screen_space_rects_)
     return;
 
   Region non_opaque_contents =
       SubtractRegions(gfx::Rect(layer->content_bounds()), opaque_contents);
-  for (Region::Iterator nonOpaqueContentRects(non_opaque_contents);
-       nonOpaqueContentRects.has_rect();
-       nonOpaqueContentRects.next()) {
-    // We've already checked for clipping in the mapQuad call above, these calls
+  for (Region::Iterator non_opaque_content_rects(non_opaque_contents);
+       non_opaque_content_rects.has_rect();
+       non_opaque_content_rects.next()) {
+    // We've already checked for clipping in the MapQuad call above, these calls
     // should not clip anything further.
     gfx::Rect transformed_rect = gfx::ToEnclosedRect(
         MathUtil::MapClippedRect(layer->draw_transform(),
-                                 gfx::RectF(nonOpaqueContentRects.rect())));
+                                 gfx::RectF(non_opaque_content_rects.rect())));
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.IsEmpty())
       continue;
 
     gfx::QuadF screen_space_quad = MathUtil::MapQuad(
         layer->render_target()->render_surface()->screen_space_transform(),
         gfx::QuadF(transformed_rect),
         &clipped);
     // TODO(danakj): Store the quad in the debug info instead of the bounding
     // box.
@@ skipping 227 matching lines @@
   }
 
   return unoccluded_rect;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc