cc: Fix capitalization style in chromified files.

cc/layers/scrollbar_layer.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.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/resources/caching_bitmap_content_layer_updater.h"
@@ skipping 12 matching lines @@
       tree_impl,
       id(),
       ScrollbarGeometryFixedThumb::Create(make_scoped_ptr(geometry_->clone())))
       .PassAs<LayerImpl>();
 }
 
 scoped_refptr<ScrollbarLayer> ScrollbarLayer::Create(
     scoped_ptr<WebKit::WebScrollbar> scrollbar,
     scoped_ptr<ScrollbarThemePainter> painter,
     scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
-    int scrollLayerId) {
+    int scroll_layer_id) {
   return make_scoped_refptr(new ScrollbarLayer(scrollbar.Pass(),
                                                painter.Pass(),
                                                geometry.Pass(),
-                                               scrollLayerId));
+                                               scroll_layer_id));
 }
 
 ScrollbarLayer::ScrollbarLayer(
     scoped_ptr<WebKit::WebScrollbar> scrollbar,
     scoped_ptr<ScrollbarThemePainter> painter,
     scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
-    int scrollLayerId)
+    int scroll_layer_id)
     : scrollbar_(scrollbar.Pass()),
       painter_(painter.Pass()),
       geometry_(geometry.Pass()),
-      scroll_layer_id_(scrollLayerId),
+      scroll_layer_id_(scroll_layer_id),
       texture_format_(GL_INVALID_ENUM) {
   if (!scrollbar_->isOverlay())
     SetShouldScrollOnMainThread(true);
 }
 
 ScrollbarLayer::~ScrollbarLayer() {}
 
 void ScrollbarLayer::SetScrollLayerId(int id) {
   if (id == scroll_layer_id_)
     return;
@@ skipping 30 matching lines @@
     else
       return (MaxTextureSize() - 1) / static_cast<float>(bounds().height());
   }
   return scale;
 }
 
 void ScrollbarLayer::CalculateContentsScale(float ideal_contents_scale,
                                             bool animating_transform_to_screen,
                                             float* contents_scale_x,
                                             float* contents_scale_y,
-                                            gfx::Size* contentBounds) {
+                                            gfx::Size* content_bounds) {
   ContentsScalingLayer::CalculateContentsScale(
       ClampScaleToMaxTextureSize(ideal_contents_scale),
       animating_transform_to_screen,
       contents_scale_x,
       contents_scale_y,
-      contentBounds);
-  DCHECK_LE(contentBounds->width(), MaxTextureSize());
-  DCHECK_LE(contentBounds->height(), MaxTextureSize());
+      content_bounds);
+  DCHECK_LE(content_bounds->width(), MaxTextureSize());
+  DCHECK_LE(content_bounds->height(), MaxTextureSize());
 }
 
 void ScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
   ContentsScalingLayer::PushPropertiesTo(layer);
 
   ScrollbarLayerImpl* scrollbar_layer = static_cast<ScrollbarLayerImpl*>(layer);
 
   scrollbar_layer->SetScrollbarData(scrollbar_.get());
   scrollbar_layer->SetThumbSize(thumb_size_);
 
   if (back_track_ && back_track_->texture()->have_backing_texture()) {
     scrollbar_layer->set_back_track_resource_id(
         back_track_->texture()->resource_id());
   } else {
     scrollbar_layer->set_back_track_resource_id(0);
   }
 
   if (fore_track_ && fore_track_->texture()->have_backing_texture()) {
     scrollbar_layer->set_fore_track_resource_id(
         fore_track_->texture()->resource_id());
   } else {
     scrollbar_layer->set_fore_track_resource_id(0);
   }
 
   if (thumb_ && thumb_->texture()->have_backing_texture())
     scrollbar_layer->set_thumb_resource_id(thumb_->texture()->resource_id());
   else
     scrollbar_layer->set_thumb_resource_id(0);
 
-  // Pinch zoom scrollbarLayerImpl does not get its scroll_layer_id_
+  // Pinch zoom ScrollbarLayerImpl does not get its scroll_layer_id_
   // set in LayerImpl, so we need to push it here.
   if (scroll_layer_id_ == Layer::PINCH_ZOOM_ROOT_SCROLL_LAYER_ID)
     scrollbar_layer->set_scroll_layer_id(scroll_layer_id_);
 }
 
 ScrollbarLayer* ScrollbarLayer::ToScrollbarLayer() {
   return this;
 }
 
 class ScrollbarBackgroundPainter : public LayerPainter {
@@ skipping 183 matching lines @@
   gfx::Rect painted_opaque_rect;
   painter->PrepareToUpdate(rect,
                            rect.size(),
                            contents_scale_x(),
                            contents_scale_y(),
                            &painted_opaque_rect,
                            stats);
   if (!painter->pixels_did_change() &&
       resource->texture()->have_backing_texture()) {
     TRACE_EVENT_INSTANT0("cc",
-                         "ScrollbarLayer::updatePart no texture upload needed");
+                         "ScrollbarLayer::UpdatePart no texture upload needed");
     return;
   }
 
   bool partial_updates_allowed =
       layer_tree_host()->settings().max_partial_texture_updates > 0;
   if (!partial_updates_allowed)
     resource->texture()->ReturnBackingTexture();
 
   gfx::Vector2d dest_offset(0, 0);
   resource->Update(queue, rect, dest_offset, partial_updates_allowed, stats);
@@ skipping 80 matching lines @@
                thumb_.get(),
                origin_thumb_rect,
                queue,
                stats);
   }
 
   dirty_rect_ = gfx::RectF();
 }
 
 }  // namespace cc