cc: Fix capitalization style in chromified files.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/picture_layer_impl.h"
 
 #include "cc/layers/picture_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 119 matching lines @@
   }
 
   FakeContentLayerClient client_;
 };
 
 class MockCanvas : public SkCanvas {
  public:
   explicit MockCanvas(SkDevice* device) : SkCanvas(device) {}
 
   virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE {
-    // Capture calls before SkCanvas quickReject kicks in
+    // Capture calls before SkCanvas quickReject() kicks in.
     rects_.push_back(rect);
   }
 
   std::vector<SkRect> rects_;
 };
 
 class PictureLayerImplTest : public testing::Test {
  public:
   PictureLayerImplTest()
       : host_impl_(ImplSidePaintingSettings(), &proxy_),
@@ skipping 95 matching lines @@
       active_pile->add_draw_rect(rect);
       rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
     }
     // Force re-record with newly injected content
     active_pile->RemoveRecordingAt(0, 0);
     active_pile->AddRecordingAt(0, 0);
 
     SkBitmap store;
     store.setConfig(SkBitmap::kNo_Config, 1000, 1000);
     SkDevice device(store);
-    int64 pixelsRasterized;
+    int64 pixels_rasterized;
 
     std::vector<SkRect>::const_iterator rect_iter = rects.begin();
     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
       MockCanvas mock_canvas(&device);
       active_pile->Raster(&mock_canvas, (*tile_iter)->content_rect(),
-          1.0f, &pixelsRasterized);
+          1.0f, &pixels_rasterized);
 
       // This test verifies that when drawing the contents of a specific tile
       // at content scale 1.0, the playback canvas never receives content from
       // neighboring tiles which indicates that the tile grid embedded in
       // SkPicture is perfectly aligned with the compositor's tiles.
       // Note: There are two rects: the initial clear and the explicitly
       // recorded rect. We only care about the second one.
       EXPECT_EQ(2, mock_canvas.rects_.size());
       EXPECT_EQ(*rect_iter, mock_canvas.rects_[1]);
       rect_iter++;
     }
   }
 
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   int id_;
   TestablePictureLayerImpl* pending_layer_;
   TestablePictureLayerImpl* active_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 };
 
-TEST_F(PictureLayerImplTest, tileGridAlignment) {
+TEST_F(PictureLayerImplTest, TileGridAlignment) {
   host_impl_.SetDeviceScaleFactor(1.f);
   TestTileGridAlignmentCommon();
 }
 
-TEST_F(PictureLayerImplTest, tileGridAlignmentHiDPI) {
+TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) {
   host_impl_.SetDeviceScaleFactor(2.f);
   TestTileGridAlignmentCommon();
 }
 
-TEST_F(PictureLayerImplTest, cloneNoInvalidation) {
+TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   EXPECT_EQ(pending_layer_->tilings().num_tilings(),
             active_layer_->tilings().num_tilings());
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i)
     VerifyAllTilesExistAndHavePile(tilings.tiling_at(i), active_pile.get());
 }
 
-TEST_F(PictureLayerImplTest, clonePartialInvalidation) {
+TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
@@ skipping 17 matching lines @@
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
         EXPECT_EQ(pending_pile, iter->picture_pile());
       else
         EXPECT_EQ(active_pile, iter->picture_pile());
     }
   }
 }
 
-TEST_F(PictureLayerImplTest, cloneFullInvalidation) {
+TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   gfx::Size tile_size(90, 80);
   gfx::Size layer_bounds(300, 500);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation((gfx::Rect(layer_bounds)));
   AddDefaultTilingsWithInvalidation(invalidation);
 
   EXPECT_EQ(pending_layer_->tilings().num_tilings(),
             active_layer_->tilings().num_tilings());
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i)
     VerifyAllTilesExistAndHavePile(tilings.tiling_at(i), pending_pile.get());
 }
 
-TEST_F(PictureLayerImplTest, noInvalidationBoundsChange) {
+TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
   gfx::Size tile_size(90, 80);
   gfx::Size active_layer_bounds(300, 500);
   gfx::Size pending_layer_bounds(400, 800);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size,
                                                 pending_layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
 
@@ skipping 20 matching lines @@
       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
           iter.geometry_rect().bottom() >= active_content_bounds.height()) {
         EXPECT_EQ(pending_pile, iter->picture_pile());
       } else {
         EXPECT_EQ(active_pile, iter->picture_pile());
       }
     }
   }
 }
 
-TEST_F(PictureLayerImplTest, addTilesFromNewRecording) {
+TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<TestablePicturePileImpl> pending_pile =
       TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<TestablePicturePileImpl> active_pile =
       TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   // Fill in some of active pile, but more of pending pile.
   int hole_count = 0;
@@ skipping 262 matching lines @@
   used_tilings.push_back(active_layer_->tilings().tiling_at(1));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 }
 
 }  // namespace
 }  // namespace cc