cc: Fix capitalization style in chromified files.

cc/layers/delegated_renderer_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/delegated_renderer_layer_impl.h"
 
 #include "base/bind.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/quad_sink.h"
@@ skipping 140 matching lines @@
     render_passes_in_draw_order_.back()->damage_rect.Union(old_root_damage);
 }
 
 void DelegatedRendererLayerImpl::ClearRenderPasses() {
   // FIXME: Release the resources back to the nested compositor.
   render_passes_index_by_id_.clear();
   render_passes_in_draw_order_.clear();
 }
 
 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
-    LayerTreeImpl* treeImpl) {
-  return DelegatedRendererLayerImpl::Create(treeImpl, id()).PassAs<LayerImpl>();
+    LayerTreeImpl* tree_impl) {
+  return DelegatedRendererLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::DidLoseOutputSurface() {
   ClearRenderPasses();
   ClearChildId();
 }
 
 gfx::Transform DelegatedRendererLayerImpl::DelegatedFrameToLayerSpaceTransform(
     gfx::Size frame_size) const {
   gfx::Size display_size = display_size_.IsEmpty() ? bounds() : display_size_;
@@ skipping 16 matching lines @@
 RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
     RenderPass::Id previous) const {
   return RenderPass::Id(previous.layer_id, previous.index + 1);
 }
 
 RenderPass::Id DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId(
     RenderPass::Id delegated_render_pass_id) const {
   base::hash_map<RenderPass::Id, int>::const_iterator found =
       render_passes_index_by_id_.find(delegated_render_pass_id);
   DCHECK(found != render_passes_index_by_id_.end());
-  unsigned delegatedRenderPassIndex = found->second;
-  return RenderPass::Id(id(), IndexToId(delegatedRenderPassIndex));
+  unsigned delegated_render_pass_index = found->second;
+  return RenderPass::Id(id(), IndexToId(delegated_render_pass_index));
 }
 
 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
     RenderPassSink* render_pass_sink) {
   DCHECK(HasContributingDelegatedRenderPasses());
 
   for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
     RenderPass::Id output_render_pass_id =
         ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id);
 
@@ skipping 12 matching lines @@
     return;
 
   RenderPass::Id target_render_pass_id = append_quads_data->renderPassId;
 
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
 
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
 
-  // If the index of the renderPassId is 0, then it is a renderPass generated
+  // If the index of the EenderPassId is 0, then it is a RenderPass generated
   // for a layer in this compositor, not the delegated renderer. Then we want to
-  // merge our root renderPass with the target renderPass. Otherwise, it is some
-  // renderPass which we added from the delegated renderer.
+  // merge our root RenderPass with the target RenderPass. Otherwise, it is some
+  // RenderPass which we added from the delegated renderer.
   bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
   if (should_merge_root_render_pass_with_target) {
-    // Verify that the renderPass we are appending to is created our
-    // renderTarget.
+    // Verify that the RenderPass we are appending to is created our
+    // render_target.
     DCHECK(target_render_pass_id.layer_id == render_target()->id());
 
     AppendRenderPassQuads(
         quad_sink, append_quads_data, root_delegated_render_pass, frame_size);
   } else {
-    // Verify that the renderPass we are appending to was created by us.
+    // Verify that the RenderPass we are appending to was created by us.
     DCHECK(target_render_pass_id.layer_id == id());
 
     int render_pass_index = IdToIndex(target_render_pass_id.index);
     const RenderPass* delegated_render_pass =
         render_passes_in_draw_order_[render_pass_index];
     AppendRenderPassQuads(
         quad_sink, append_quads_data, delegated_render_pass, frame_size);
   }
 }
 
@@ skipping 84 matching lines @@
 void DelegatedRendererLayerImpl::ClearChildId() {
   if (!child_id_)
     return;
 
   ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
   resource_provider->DestroyChild(child_id_);
   child_id_ = 0;
 }
 
 }  // namespace cc