cc: Fix capitalization style in chromified files.

cc/layers/picture_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/picture_layer_impl.h"
 
 #include "base/time.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/debug_colors.h"
@@ skipping 64 matching lines @@
   layer_impl->TransferTilingSet(tilings_.Pass());
   layer_impl->pile_ = pile_;
   pile_ = PicturePileImpl::Create();
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
 }
 
 
-void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
-                                   AppendQuadsData* appendQuadsData) {
+void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
+                                   AppendQuadsData* append_quads_data) {
   const gfx::Rect& rect = visible_content_rect();
   gfx::Rect content_rect(content_bounds());
 
-  SharedQuadState* sharedQuadState =
-      quadSink->UseSharedQuadState(CreateSharedQuadState());
-  AppendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
+  SharedQuadState* shared_quad_state =
+      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   bool clipped = false;
   gfx::QuadF target_quad = MathUtil::MapQuad(
       draw_transform(),
       gfx::QuadF(rect),
       &clipped);
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                               contents_scale_x(),
                                               rect,
@@ skipping 19 matching lines @@
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
           color = DebugColors::ExtraLowResTileBorderColor();
           width = DebugColors::ExtraLowResTileBorderWidth(layer_tree_impl());
         }
       } else {
         color = DebugColors::MissingTileBorderColor();
         width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
       }
 
-      scoped_ptr<DebugBorderDrawQuad> debugBorderQuad =
+      scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
           DebugBorderDrawQuad::Create();
       gfx::Rect geometry_rect = iter.geometry_rect();
-      debugBorderQuad->SetNew(sharedQuadState, geometry_rect, color, width);
-      quadSink->Append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
+      debug_border_quad->SetNew(shared_quad_state, geometry_rect, color, width);
+      quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(),
+                        append_quads_data);
     }
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
   for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             contents_scale_x(),
                                             rect,
                                             ideal_contents_scale_);
        iter;
        ++iter) {
 
     gfx::Rect geometry_rect = iter.geometry_rect();
     if (!*iter || !iter->drawing_info().IsReadyToDraw()) {
       if (DrawCheckerboardForMissingTiles()) {
         // TODO(enne): Figure out how to show debug "invalidated checker" color
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
         SkColor color = DebugColors::DefaultCheckerboardColor();
-        quad->SetNew(sharedQuadState, geometry_rect, color);
-        if (quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData))
-          appendQuadsData->numMissingTiles++;
+        quad->SetNew(shared_quad_state, geometry_rect, color);
+        if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
+          append_quads_data->numMissingTiles++;
       } else {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(sharedQuadState, geometry_rect, background_color());
-        if (quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData))
-          appendQuadsData->numMissingTiles++;
+        quad->SetNew(shared_quad_state, geometry_rect, background_color());
+        if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
+          append_quads_data->numMissingTiles++;
       }
 
-      appendQuadsData->hadIncompleteTile = true;
+      append_quads_data->hadIncompleteTile = true;
       continue;
     }
 
     const ManagedTileState::DrawingInfo& drawing_info = iter->drawing_info();
     switch (drawing_info.mode()) {
       case ManagedTileState::DrawingInfo::TEXTURE_MODE: {
         if (iter->contents_scale() != ideal_contents_scale_)
-          appendQuadsData->hadIncompleteTile = true;
+          append_quads_data->hadIncompleteTile = true;
 
         gfx::RectF texture_rect = iter.texture_rect();
         gfx::Rect opaque_rect = iter->opaque_rect();
         opaque_rect.Intersect(content_rect);
 
         scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
-        quad->SetNew(sharedQuadState,
+        quad->SetNew(shared_quad_state,
                      geometry_rect,
                      opaque_rect,
                      drawing_info.get_resource_id(),
                      texture_rect,
                      iter.texture_size(),
                      drawing_info.contents_swizzled());
-        quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
         break;
       }
       case ManagedTileState::DrawingInfo::SOLID_COLOR_MODE: {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(sharedQuadState,
+        quad->SetNew(shared_quad_state,
                      geometry_rect,
                      drawing_info.get_solid_color());
-        quadSink->Append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
         break;
       }
       case ManagedTileState::DrawingInfo::TRANSPARENT_MODE:
         break;
       case ManagedTileState::DrawingInfo::PICTURE_PILE_MODE:
         // TODO: crbug.com/173011 would fill this part in.
       default:
         NOTREACHED();
     }
 
     if (!seen_tilings.size() || seen_tilings.back() != iter.CurrentTiling())
       seen_tilings.push_back(iter.CurrentTiling());
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
-  // better scheme would be to maintain a tighter visibleContentRect for the
+  // better scheme would be to maintain a tighter visible_content_rect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(seen_tilings);
 }
 
 void PictureLayerImpl::DumpLayerProperties(std::string*, int indent) const {
   // TODO(enne): implement me
 }
 
 void PictureLayerImpl::UpdateTilePriorities() {
   int current_source_frame_number = layer_tree_impl()->source_frame_number();
@@ skipping 143 matching lines @@
   if (any_dimension_one_tile || !any_dimension_too_large) {
     int width =
         std::min(max_untiled_content_size.width(), content_bounds.width());
     int height =
         std::min(max_untiled_content_size.height(), content_bounds.height());
     // Round width and height up to the closest multiple of 64, or 56 if
     // we should avoid power-of-two textures. This helps reduce the number
     // of different textures sizes to help recycling, and also keeps all
     // textures multiple-of-eight, which is preferred on some drivers (IMG).
     bool avoid_pow2 =
-        layer_tree_impl()->rendererCapabilities().avoid_pow2_textures;
+        layer_tree_impl()->GetRendererCapabilities().avoid_pow2_textures;
     int round_up_to = avoid_pow2 ? 56 : 64;
     width = RoundUp(width, round_up_to);
     height = RoundUp(height, round_up_to);
     return gfx::Size(width, height);
   }
 
   return default_tile_size;
 }
 
 void PictureLayerImpl::SyncFromActiveLayer() {
@@ skipping 412 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc