cc: Fix capitalization style in chromified files.

cc/trees/damage_tracker_unittest.cc

 // Copyright 2011 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/trees/damage_tracker.h"
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 38 matching lines @@
 
   // Recursively clear damage for any existing surface.
   for (size_t i = 0; i < layer->children().size(); ++i)
     ClearDamageForAllSurfaces(layer->children()[i]);
 }
 
 void EmulateDrawingOneFrame(LayerImpl* root) {
   // This emulates only steps that are relevant to testing the damage tracker:
   //   1. computing the render passes and layerlists
   //   2. updating all damage trackers in the correct order
-  //   3. resetting all update_rects and propertyChanged flags for all layers
+  //   3. resetting all update_rects and property_changed flags for all layers
   //      and surfaces.
 
   std::vector<LayerImpl*> render_surface_layer_list;
   ExecuteCalculateDrawProperties(root, render_surface_layer_list);
 
   // Iterate back-to-front, so that damage correctly propagates from descendant
   // surfaces to ancestors.
   for (int i = render_surface_layer_list.size() - 1; i >= 0; --i) {
     RenderSurfaceImpl* target_surface =
             render_surface_layer_list[i]->render_surface();
@@ skipping 61 matching lines @@
     root->SetContentBounds(gfx::Size(500, 500));
     root->SetDrawsContent(true);
     root->CreateRenderSurface();
     root->render_surface()->SetContentRect(
         gfx::Rect(gfx::Point(), gfx::Size(500, 500)));
 
     child1->SetPosition(gfx::PointF(100.f, 100.f));
     child1->SetAnchorPoint(gfx::PointF());
     child1->SetBounds(gfx::Size(30, 30));
     child1->SetContentBounds(gfx::Size(30, 30));
-    // With a child that drawsContent, opacity will cause the layer to create
-    // its own renderSurface. This layer does not draw, but is intended to
-    // create its own renderSurface. TODO: setting opacity and
-    // forceRenderSurface may be redundant here.
+    // With a child that draws_content, opacity will cause the layer to create
+    // its own RenderSurface. This layer does not draw, but is intended to
+    // create its own RenderSurface. TODO: setting opacity and
+    // ForceRenderSurface may be redundant here.
     child1->SetOpacity(0.5f);
     child1->SetDrawsContent(false);
     child1->SetForceRenderSurface(true);
 
     child2->SetPosition(gfx::PointF(11.f, 11.f));
     child2->SetAnchorPoint(gfx::PointF());
     child2->SetBounds(gfx::Size(18, 18));
     child2->SetContentBounds(gfx::Size(18, 18));
     child2->SetDrawsContent(true);
 
@@ skipping 69 matching lines @@
   gfx::RectF child_damage_rect =
           child1->render_surface()->damage_tracker()->current_damage_rect();
   gfx::RectF root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
 
   ASSERT_TRUE(child1->render_surface());
   EXPECT_FALSE(child2->render_surface());
   EXPECT_EQ(3u, root->render_surface()->layer_list().size());
   EXPECT_EQ(2u, child1->render_surface()->layer_list().size());
 
-  // The render surface for child1 only has a contentRect that encloses
+  // The render surface for child1 only has a content_rect that encloses
   // grand_child1 and grand_child2, because child1 does not draw content.
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 16.f, 18.f), child_damage_rect);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 500.f, 500.f), root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->children()[0];
 
   // CASE 1: Setting the update rect should cause the corresponding damage to
@@ skipping 293 matching lines @@
   // update_rect (297, 297), but expanded on the left/top by the blur outsets.
   expected_damage_rect =
           gfx::RectF(297.f, 297.f, 30.f, 30.f);
 
   expected_damage_rect.Inset(-outset_left,
                              -outset_top,
                              0,
                              0);
   EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
 
-  // CASE 3: Setting this update rect outside the blurred contentBounds of the
+  // CASE 3: Setting this update rect outside the blurred content_bounds of the
   //         blurred child1 will not cause it to be expanded.
   ClearDamageForAllSurfaces(root.get());
   root->set_update_rect(gfx::RectF(30.f, 30.f, 2.f, 2.f));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage on the root should be: position of update_rect (30, 30), not
   // expanded.
   expected_damage_rect =
           gfx::RectF(30.f, 30.f, 2.f, 2.f);
 
   EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
 
-  // CASE 4: Setting this update rect inside the blurred contentBounds but
-  //         outside the original contentBounds of the blurred child1 will
+  // CASE 4: Setting this update rect inside the blurred content_bounds but
+  //         outside the original content_bounds of the blurred child1 will
   //         cause it to be expanded.
   ClearDamageForAllSurfaces(root.get());
   root->set_update_rect(gfx::RectF(99.f, 99.f, 1.f, 1.f));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage on the root should be: position of update_rect (99, 99), expanded by
   // the blurring on child1, but since it is 1 pixel outside the layer, the
   // expanding should be reduced by 1.
@@ skipping 223 matching lines @@
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 11.f, 23.f), child_damage_rect);
 
   // Damage to the root surface should be the union of child1's *entire* render
   // surface (in target space), and its old exposed area (also in target
   // space).
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(290.f, 290.f, 16.f, 23.f), root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
   // An ancestor/owning layer changes that affects the position/transform of
-  // the render surface. Note that in this case, the layerPropertyChanged flag
+  // the render surface. Note that in this case, the layer_property_changed flag
   // already propagates to the subtree (tested in LayerImpltest), which damages
   // the entire child1 surface, but the damage tracker still needs the correct
   // logic to compute the exposed region on the root surface.
 
   // FIXME: the expectations of this test case should change when we add
-  //        support for a unique scissorRect per renderSurface. In that case,
+  //        support for a unique scissor_rect per RenderSurface. In that case,
   //        the child1 surface should be completely unchanged, since we are
   //        only transforming it, while the root surface would be damaged
   //        appropriately.
 
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0];
   gfx::RectF child_damage_rect;
   gfx::RectF root_damage_rect;
 
   ClearDamageForAllSurfaces(root.get());
@@ skipping 118 matching lines @@
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0];
   LayerImpl* grand_child1 = child1->children()[0];
   LayerImpl* grand_child2 = child1->children()[1];
 
   // Damage on a surface that has a reflection should cause the target surface
   // to receive the surface's damage and the surface's reflected damage.
 
   // For this test case, we modify grand_child2, and add grand_child3 to extend
   // the bounds of child1's surface. This way, we can test reflection changes
-  // without changing contentBounds of the surface.
+  // without changing content_bounds of the surface.
   grand_child2->SetPosition(gfx::PointF(180.f, 180.f));
   {
     scoped_ptr<LayerImpl> grand_child3 =
             LayerImpl::Create(host_impl_.active_tree(), 6);
     grand_child3->SetPosition(gfx::PointF(240.f, 240.f));
     grand_child3->SetAnchorPoint(gfx::PointF());
     grand_child3->SetBounds(gfx::Size(10, 10));
     grand_child3->SetContentBounds(gfx::Size(10, 10));
     grand_child3->SetDrawsContent(true);
     child1->AddChild(grand_child3.Pass());
@@ skipping 240 matching lines @@
 
   EXPECT_TRUE(grand_child_damage_rect.IsEmpty());
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(194.f, 200.f, 6.f, 8.f), child_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithAnchor) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0];
   LayerImpl* grand_child1 = child1->children()[0];
 
-  // Verify that the correct replicaOriginTransform is used for the replicaMask
+  // Verify that the correct replica_origin_transform is used for the
+  // replica_mask.
   ClearDamageForAllSurfaces(root.get());
 
   // This is not actually the anchor point being tested, but by convention its
   // expected to be the same as the replica's anchor point.
   grand_child1->SetAnchorPoint(gfx::PointF(1.f, 0.f));
 
   {
     scoped_ptr<LayerImpl> grand_child1_replica =
             LayerImpl::Create(host_impl_.active_tree(), 6);
     grand_child1_replica->SetPosition(gfx::PointF());
@@ skipping 18 matching lines @@
     replica_mask_layer->SetContentBounds(grand_child1->bounds());
     grand_child1_replica->SetMaskLayer(replica_mask_layer.Pass());
   }
   LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer();
 
   EmulateDrawingOneFrame(root.get());
 
   // Sanity check that the appropriate render surfaces were created
   ASSERT_TRUE(grand_child1->render_surface());
 
-  // A property change on the replicaMask should damage the reflected region on
+  // A property change on the replica_mask should damage the reflected region on
   // the target surface.
   ClearDamageForAllSurfaces(root.get());
   replica_mask_layer->SetStackingOrderChanged(true);
 
   EmulateDrawingOneFrame(root.get());
 
   gfx::RectF child_damage_rect =
           child1->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(206.f, 200.f, 6.f, 8.f), child_damage_rect);
 }
@@ skipping 19 matching lines @@
   ClearDamageForAllSurfaces(root.get());
   root->render_surface()->damage_tracker()->ForceFullDamageNextUpdate();
   EmulateDrawingOneFrame(root.get());
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 500.f, 500.f), root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) {
   // Though it should never happen, its a good idea to verify that the damage
-  // tracker does not crash when it receives an empty layerList.
+  // tracker does not crash when it receives an empty layer_list.
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.active_tree(), 1);
   root->CreateRenderSurface();
 
   ASSERT_TRUE(root == root->render_target());
   RenderSurfaceImpl* target_surface = root->render_surface();
   target_surface->ClearLayerLists();
   target_surface->damage_tracker()->UpdateDamageTrackingState(
       target_surface->layer_list(),
       target_surface->OwningLayerId(),
@@ skipping 41 matching lines @@
   // Damage should remain empty even after one frame, since there's yet no new
   // damage.
   EmulateDrawingOneFrame(root.get());
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 }
 
 }  // namespace
 }  // namespace cc