cc: Fix capitalization style in chromified files.

cc/layers/delegated_renderer_layer_impl_unittest.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 "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/solid_color_layer_impl.h"
@@ skipping 75 matching lines @@
 
     delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
     delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
     delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
     delegated_renderer_layer->SetDrawsContent(true);
     gfx::Transform transform;
     transform.Translate(1.0, 1.0);
     delegated_renderer_layer->SetTransform(transform);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
-    TestRenderPass* pass1 = addRenderPass(
+    TestRenderPass* pass1 = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         gfx::Rect(6, 6, 6, 6),
         gfx::Transform());
-    addQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
-    TestRenderPass* pass2 = addRenderPass(
+    AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
+    TestRenderPass* pass2 = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 7),
         gfx::Rect(7, 7, 7, 7),
         gfx::Transform());
-    addQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
-    addRenderPassQuad(pass2, pass1);
-    TestRenderPass* pass3 = addRenderPass(
+    AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
+    AddRenderPassQuad(pass2, pass1);
+    TestRenderPass* pass3 = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 8),
         gfx::Rect(0, 0, 8, 8),
         gfx::Transform());
-    addRenderPassQuad(pass3, pass2);
+    AddRenderPassQuad(pass3, pass2);
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         &delegated_render_passes);
 
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     layer_before_ = layer_before.get();
     layer_after_ = layer_after.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
@@ skipping 144 matching lines @@
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
   LayerTreeHostImpl::FrameData frame;
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
-  // has no need to be a renderSurface for the quads it carries.
+  // has no need to be a RenderSurface for the quads it carries.
   EXPECT_FALSE(delegated_renderer_layer_->render_surface());
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
   delegated_renderer_layer_->SetOpacity(0.5f);
 
   LayerTreeHostImpl::FrameData frame;
@@ skipping 192 matching lines @@
 
     gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     child_pass_transform.Scale(0.8, 0.8);
     child_pass_transform.Translate(9.0, 9.0);
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
 
     {
-      TestRenderPass* pass = addRenderPass(
+      TestRenderPass* pass = AddRenderPass(
           delegated_render_passes,
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
       MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
       AppendQuadsData data(pass->id);
       SharedQuadState* shared_quad_state = quad_sink.UseSharedQuadState(
           SharedQuadState::Create());
       shared_quad_state->SetAll(
           child_pass_transform,
@@ skipping 14 matching lines @@
     }
 
     gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     root_pass_transform.Scale(1.5, 1.5);
     root_pass_transform.Translate(7.0, 7.0);
     gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
-    TestRenderPass* pass = addRenderPass(
+    TestRenderPass* pass = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
     MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state =
         quad_sink.UseSharedQuadState(SharedQuadState::Create());
     shared_quad_state->SetAll(
         root_pass_transform,
@@ skipping 105 matching lines @@
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the quads don't have a clip of their own, the clip rect is set to
-  // the drawableContentRect of the delegated renderer layer.
+  // the drawable_content_rect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(21, 21, 60, 60).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
   // Even though the quads in the root pass have no clip of their own, they
   // inherit the clip rect from the delegated renderer layer if it does not
   // own a surface.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   gfx::Transform expected;
   // This is the transform from the layer's space to its target.
@@ skipping 33 matching lines @@
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // Since the quads have a clip_rect it should be modified by delegated
-  // renderer layer's drawTransform.
+  // renderer layer's draw_transform.
   // The position of the resulting clip_rect is:
   // (clip rect position (10) * scale to layer (30/50) + translate (8)) *
   //     layer scale (2) + layer position (20) = 48
   // But the layer is centered, so: 48 - (width / 2) = 48 - 30 / 2 = 33
   //
   // The size is 35x35 scaled to fit inside the layer's bounds at 30x30 from
   // a frame at 50x50: 35 * 2 (layer's scale) * 30 / 50 = 42.
   EXPECT_EQ(gfx::Rect(33, 33, 42, 42).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
@@ skipping 161 matching lines @@
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
     gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
 
     {
-      TestRenderPass* pass = addRenderPass(
+      TestRenderPass* pass = AddRenderPass(
           delegated_render_passes,
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
       MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
       AppendQuadsData data(pass->id);
       SharedQuadState* shared_quad_state =
           quad_sink.UseSharedQuadState(SharedQuadState::Create());
       shared_quad_state->SetAll(
           child_pass_transform,
@@ skipping 12 matching lines @@
       color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
       quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
     }
 
     gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
-    TestRenderPass* pass = addRenderPass(
+    TestRenderPass* pass = AddRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
     MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state =
         quad_sink.UseSharedQuadState(SharedQuadState::Create());
     shared_quad_state->SetAll(root_pass_transform,
                               root_pass_content_bounds,
@@ skipping 85 matching lines @@
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
-  // the drawableContentRect of the delegated renderer layer.
+  // the drawable_content_rect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
@@ skipping 41 matching lines @@
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
-  // the drawableContentRect of the delegated renderer layer. When the layer
+  // the drawable_content_rect of the delegated renderer layer. When the layer
   // is clipped, that should be seen in the quads' clip_rect.
   EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
@@ skipping 150 matching lines @@
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 }  // namespace
 }  // namespace cc