cc: Fix capitalization style in chromified files.

cc/output/direct_renderer.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/output/direct_renderer.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
@@ skipping 50 matching lines @@
 DirectRenderer::DrawingFrame::~DrawingFrame() {}
 
 //
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
 }
 
 // static
 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
-                                       const gfx::Transform& quadTransform,
-                                       const gfx::RectF& quadRect) {
-  *quad_rect_transform = quadTransform;
-  quad_rect_transform->Translate(0.5 * quadRect.width() + quadRect.x(),
-                                 0.5 * quadRect.height() + quadRect.y());
-  quad_rect_transform->Scale(quadRect.width(), quadRect.height());
+                                       const gfx::Transform& quad_transform,
+                                       const gfx::RectF& quad_rect) {
+  *quad_rect_transform = quad_transform;
+  quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(),
+                                 0.5 * quad_rect.height() + quad_rect.y());
+  quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
 }
 
 // static
 void DirectRenderer::InitializeMatrices(DrawingFrame& frame,
                                         gfx::Rect draw_rect,
                                         bool flip_y) {
   if (flip_y) {
     frame.projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
                                                     draw_rect.right(),
                                                     draw_rect.bottom(),
@@ skipping 37 matching lines @@
 
 DirectRenderer::~DirectRenderer() {}
 
 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
     gfx::Vector2d amount) {
   enlarge_pass_texture_amount_ = amount;
 }
 
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
-  base::hash_map<RenderPass::Id, const RenderPass*> renderPassesInFrame;
+  base::hash_map<RenderPass::Id, const RenderPass*> render_passes_in_frame;
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
-    renderPassesInFrame.insert(std::pair<RenderPass::Id, const RenderPass*>(
+    render_passes_in_frame.insert(std::pair<RenderPass::Id, const RenderPass*>(
         render_passes_in_draw_order[i]->id, render_passes_in_draw_order[i]));
 
   std::vector<RenderPass::Id> passes_to_delete;
-  ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator passIterator;
-  for (passIterator = render_pass_textures_.begin();
-       passIterator != render_pass_textures_.end();
-       ++passIterator) {
+  ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator pass_iter;
+  for (pass_iter = render_pass_textures_.begin();
+       pass_iter != render_pass_textures_.end();
+       ++pass_iter) {
     base::hash_map<RenderPass::Id, const RenderPass*>::const_iterator it =
-        renderPassesInFrame.find(passIterator->first);
-    if (it == renderPassesInFrame.end()) {
-      passes_to_delete.push_back(passIterator->first);
+        render_passes_in_frame.find(pass_iter->first);
+    if (it == render_passes_in_frame.end()) {
+      passes_to_delete.push_back(pass_iter->first);
       continue;
     }
 
     const RenderPass* render_pass_in_frame = it->second;
     gfx::Size required_size = RenderPassTextureSize(render_pass_in_frame);
     GLenum required_format = RenderPassTextureFormat(render_pass_in_frame);
-    CachedResource* texture = passIterator->second;
+    CachedResource* texture = pass_iter->second;
     DCHECK(texture);
 
     bool size_appropriate = texture->size().width() >= required_size.width() &&
                            texture->size().height() >= required_size.height();
     if (texture->id() &&
         (!size_appropriate || texture->format() != required_format))
       texture->Free();
   }
 
   // Delete RenderPass textures from the previous frame that will not be used
   // again.
   for (size_t i = 0; i < passes_to_delete.size(); ++i)
     render_pass_textures_.erase(passes_to_delete[i]);
 
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
     if (!render_pass_textures_.contains(render_passes_in_draw_order[i]->id)) {
       scoped_ptr<CachedResource> texture =
           CachedResource::Create(resource_provider_);
       render_pass_textures_.set(render_passes_in_draw_order[i]->id,
                               texture.Pass());
     }
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList& render_passes_in_draw_order) {
-  TRACE_EVENT0("cc", "DirectRenderer::drawFrame");
+  TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
                        render_passes_in_draw_order.size());
 
   const RenderPass* root_render_pass = render_passes_in_draw_order.back();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.root_render_pass = root_render_pass;
   frame.root_damage_rect =
       Capabilities().using_partial_swap ?
       root_render_pass->damage_rect : root_render_pass->output_rect;
   frame.root_damage_rect.Intersect(gfx::Rect(gfx::Point(), ViewportSize()));
 
   BeginDrawingFrame(frame);
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
     DrawRenderPass(frame, render_passes_in_draw_order[i]);
   FinishDrawingFrame(frame);
 
   render_passes_in_draw_order.clear();
 }
 
 gfx::RectF DirectRenderer::ComputeScissorRectForRenderPass(
     const DrawingFrame& frame) {
   gfx::RectF render_pass_scissor = frame.current_render_pass->output_rect;
 
   if (frame.root_damage_rect == frame.root_render_pass->output_rect)
     return render_pass_scissor;
 
-  gfx::Transform inverseTransform(gfx::Transform::kSkipInitialization);
+  gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
   if (frame.current_render_pass->transform_to_root_target.GetInverse(
-          &inverseTransform)) {
+          &inverse_transform)) {
     // Only intersect inverse-projected damage if the transform is invertible.
     gfx::RectF damage_rect_in_render_pass_space =
-        MathUtil::ProjectClippedRect(inverseTransform, frame.root_damage_rect);
+        MathUtil::ProjectClippedRect(inverse_transform, frame.root_damage_rect);
     render_pass_scissor.Intersect(damage_rect_in_render_pass_space);
   }
 
   return render_pass_scissor;
 }
 
 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame& frame,
                                             const DrawQuad& quad) {
   if (quad.isClipped()) {
     gfx::RectF quad_scissor_rect = quad.clipRect();
@@ skipping 19 matching lines @@
   }
 
   *should_skip_quad = false;
   SetScissorTestRect(MoveScissorToWindowSpace(frame, quad_scissor_rect));
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
 void DirectRenderer::DrawRenderPass(DrawingFrame& frame,
                                     const RenderPass* render_pass) {
-  TRACE_EVENT0("cc", "DirectRenderer::drawRenderPass");
+  TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
   bool using_scissor_as_optimization = Capabilities().using_partial_swap;
   gfx::RectF render_pass_scissor;
 
   if (using_scissor_as_optimization) {
     render_pass_scissor = ComputeScissorRectForRenderPass(frame);
     SetScissorTestRect(MoveScissorToWindowSpace(frame, render_pass_scissor));
   }
 
   if (frame.current_render_pass != frame.root_render_pass ||
       client_->ShouldClearRootRenderPass()) {
     if (!using_scissor_as_optimization)
       EnsureScissorTestDisabled();
     ClearFramebuffer(frame);
   }
 
   const QuadList& quad_list = render_pass->quad_list;
-  for (QuadList::constBackToFrontIterator it = quad_list.backToFrontBegin();
-       it != quad_list.backToFrontEnd();
+  for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
+       it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad& quad = *(*it);
     bool should_skip_quad = false;
 
     if (using_scissor_as_optimization) {
       SetScissorStateForQuadWithRenderPassScissor(
           frame, quad, render_pass_scissor, &should_skip_quad);
     } else {
       SetScissorStateForQuad(frame, quad);
     }
@@ skipping 50 matching lines @@
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::RenderPassTextureFormat(const RenderPass* render_pass) {
   return GL_RGBA;
 }
 
 }  // namespace cc