cc: Fix capitalization style in chromified files.

cc/layers/scrollbar_layer_impl.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/layers/scrollbar_layer_impl.h"
 
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ skipping 133 matching lines @@
   scrollbar_layer->set_fore_track_resource_id(fore_track_resource_id_);
   scrollbar_layer->set_thumb_resource_id(thumb_resource_id_);
 }
 
 void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
                                      AppendQuadsData* append_quads_data) {
   bool premultipled_alpha = true;
   bool flipped = false;
   gfx::PointF uv_top_left(0.f, 0.f);
   gfx::PointF uv_bottom_right(1.f, 1.f);
-  gfx::Rect boundsRect(bounds());
-  gfx::Rect contentBoundsRect(content_bounds());
+  gfx::Rect bounds_rect(bounds());
+  gfx::Rect content_bounds_rect(content_bounds());
 
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   if (layer_tree_impl()->settings().solid_color_scrollbars) {
     gfx::Rect track_rect = geometry_->trackRect(&scrollbar_);
     int thickness_override =
         layer_tree_impl()->settings().solid_color_scrollbar_thickness_dip;
     gfx::RectF thumb_rect;
@@ skipping 18 matching lines @@
     }
     gfx::Rect quad_rect(ScrollbarLayerRectToContentRect(thumb_rect));
     scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  quad_rect,
                  layer_tree_impl()->settings().solid_color_scrollbar_color);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
     return;
   }
 
-  WebRect thumb_rect, back_track_rect, foreTrackRect;
+  WebRect thumb_rect, back_track_rect, fore_track_rect;
   geometry_->splitTrack(&scrollbar_,
                         geometry_->trackRect(&scrollbar_),
                         back_track_rect,
                         thumb_rect,
-                        foreTrackRect);
+                        fore_track_rect);
   if (!geometry_->hasThumb(&scrollbar_))
     thumb_rect = WebRect();
 
   if (thumb_resource_id_ && !thumb_rect.isEmpty()) {
     gfx::Rect quad_rect(ScrollbarLayerRectToContentRect(gfx::Rect(thumb_rect)));
     gfx::Rect opaque_rect;
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  quad_rect,
                  opaque_rect,
                  thumb_resource_id_,
                  premultipled_alpha,
                  uv_top_left,
                  uv_bottom_right,
                  opacity,
                  flipped);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
   }
 
   if (!back_track_resource_id_)
     return;
 
   // We only paint the track in two parts if we were given a texture for the
   // forward track part.
-  if (fore_track_resource_id_ && !foreTrackRect.isEmpty()) {
+  if (fore_track_resource_id_ && !fore_track_rect.isEmpty()) {
     gfx::Rect quad_rect(ScrollbarLayerRectToContentRect(
-        gfx::Rect(foreTrackRect)));
+        gfx::Rect(fore_track_rect)));
     gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
-    gfx::RectF uv_rect(ToUVRect(foreTrackRect, boundsRect));
+    gfx::RectF uv_rect(ToUVRect(fore_track_rect, bounds_rect));
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  quad_rect,
                  opaque_rect,
                  fore_track_resource_id_,
                  premultipled_alpha,
                  uv_rect.origin(),
                  uv_rect.bottom_right(),
                  opacity,
                  flipped);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
   }
 
   // Order matters here: since the back track texture is being drawn to the
   // entire contents rect, we must append it after the thumb and fore track
   // quads. The back track texture contains (and displays) the buttons.
-  if (!contentBoundsRect.IsEmpty()) {
-    gfx::Rect quad_rect(contentBoundsRect);
+  if (!content_bounds_rect.IsEmpty()) {
+    gfx::Rect quad_rect(content_bounds_rect);
     gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  quad_rect,
                  opaque_rect,
                  back_track_resource_id_,
                  premultipled_alpha,
                  uv_top_left,
                  uv_bottom_right,
@@ skipping 74 matching lines @@
 
 bool ScrollbarLayerImpl::Scrollbar::isCustomScrollbar() const {
   return owner_->is_custom_scrollbar_;
 }
 
 const char* ScrollbarLayerImpl::LayerTypeAsString() const {
   return "ScrollbarLayer";
 }
 
 }  // namespace cc