cc: Fix capitalization style in chromified files.

cc/layers/nine_patch_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 "nine_patch_layer_impl.h"
 
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/quads/texture_draw_quad.h"
@@ skipping 84 matching lines @@
     float top_height_proportion =
         static_cast<float>(top_height) / corner_total_height;
     int top_height_crop = middle_height * top_height_proportion;
     top_height += top_height_crop;
     bottom_height = bounds().height() - top_height;
     middle_height = 0;
   }
 
   // Patch positions in layer space
   gfx::Rect top_left(0, 0, left_width, top_height);
-  gfx::Rect topRight(
+  gfx::Rect top_right(
       bounds().width() - right_width, 0, right_width, top_height);
-  gfx::Rect bottomLeft(
+  gfx::Rect bottom_left(
       0, bounds().height() - bottom_height, left_width, bottom_height);
-  gfx::Rect bottomRight(
-      topRight.x(), bottomLeft.y(), right_width, bottom_height);
+  gfx::Rect bottom_right(
+      top_right.x(), bottom_left.y(), right_width, bottom_height);
   gfx::Rect top(top_left.right(), 0, middle_width, top_height);
   gfx::Rect left(0, top_left.bottom(), left_width, middle_height);
-  gfx::Rect right(topRight.x(), topRight.bottom(), right_width, left.height());
-  gfx::Rect bottom(top.x(), bottomLeft.y(), top.width(), bottom_height);
+  gfx::Rect right(top_right.x(), top_right.bottom(), right_width, left.height());
+  gfx::Rect bottom(top.x(), bottom_left.y(), top.width(), bottom_height);
 
   float img_width = image_bounds_.width();
   float img_height = image_bounds_.height();
 
   // Patch positions in bitmap UV space (from zero to one)
   gfx::RectF uv_top_left = NormalizedRect(0,
                                           0,
                                           left_width,
                                           top_height,
                                           img_width,
                                           img_height);
   gfx::RectF uv_top_right = NormalizedRect(img_width - right_width,
                                            0,
                                            right_width,
                                            top_height,
                                            img_width,
                                            img_height);
   gfx::RectF uv_bottom_left = NormalizedRect(0,
                                              img_height - bottom_height,
                                              left_width,
                                              bottom_height,
                                              img_width,
                                              img_height);
   gfx::RectF uv_bottom_right = NormalizedRect(img_width - right_width,
                                               img_height - bottom_height,
                                               right_width,
                                               bottom_height,
                                               img_width,
                                               img_height);
-  gfx::RectF uvTop(uv_top_left.right(),
+  gfx::RectF uv_top(uv_top_left.right(),
                    0,
                    (img_width - left_width - right_width) / img_width,
                    (top_height) / img_height);
-  gfx::RectF uvLeft(0,
+  gfx::RectF uv_left(0,
                     uv_top_left.bottom(),
                     left_width / img_width,
                     (img_height - top_height - bottom_height) / img_height);
-  gfx::RectF uvRight(uv_top_right.x(),
+  gfx::RectF uv_right(uv_top_right.x(),
                      uv_top_right.bottom(),
                      right_width / img_width,
-                     uvLeft.height());
-  gfx::RectF uvBottom(uvTop.x(),
+                     uv_left.height());
+  gfx::RectF uv_bottom(uv_top.x(),
                       uv_bottom_left.y(),
-                      uvTop.width(),
+                      uv_top.width(),
                       bottom_height / img_height);
 
   // Nothing is opaque here.
   // TODO(danakj): Should we look at the SkBitmaps to determine opaqueness?
   gfx::Rect opaque_rect;
   const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
   scoped_ptr<TextureDrawQuad> quad;
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                top_left,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_top_left.origin(),
                uv_top_left.bottom_right(),
                vertex_opacity, flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
-               topRight,
+               top_right,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_top_right.origin(),
                uv_top_right.bottom_right(),
                vertex_opacity, flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
-               bottomLeft,
+               bottom_left,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_bottom_left.origin(),
                uv_bottom_left.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
-               bottomRight,
+               bottom_right,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_bottom_right.origin(),
                uv_bottom_right.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                top,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvTop.origin(),
-               uvTop.bottom_right(),
+               uv_top.origin(),
+               uv_top.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                left,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvLeft.origin(),
-               uvLeft.bottom_right(),
+               uv_left.origin(),
+               uv_left.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                right,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvRight.origin(),
-               uvRight.bottom_right(),
+               uv_right.origin(),
+               uv_right.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                bottom,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
-               uvBottom.origin(),
-               uvBottom.bottom_right(),
+               uv_bottom.origin(),
+               uv_bottom.bottom_right(),
                vertex_opacity,
                flipped);
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 }
 
 void NinePatchLayerImpl::DidDraw(ResourceProvider* resource_provider) {}
 
 void NinePatchLayerImpl::DidLoseOutputSurface() {
   resource_id_ = 0;
 }
@@ skipping 24 matching lines @@
 
   list = new base::ListValue;
   list->AppendInteger(image_bounds_.width());
   list->AppendInteger(image_bounds_.height());
   result->Set("ImageBounds", list);
 
   return result;
 }
 
 }  // namespace cc