cc: Chromify the OverdrawMetrics class.

cc/quad_culler_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/quad_culler.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
@@ skipping 106 matching lines @@
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, false, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 13u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 40000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 40000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullChildLinesUpTopLeft)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 9u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 40000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 40000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullWhenChildOpacityNotOne)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 0.9f, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 13u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 40000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 40000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullWhenChildOpaqueFlagFalse)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, false, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 13u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 40000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 40000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullCenterTileOnly)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     childTransform.Translate(50, 50);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
@@ skipping 12 matching lines @@
 
     // Next index is 8, not 9, since centre quad culled.
     gfx::Rect quadVisibleRect4 = quadList[8]->visible_rect;
     EXPECT_EQ(quadVisibleRect4.width(), 50);
     EXPECT_EQ(quadVisibleRect4.x(), 250);
 
     gfx::Rect quadVisibleRect6 = quadList[10]->visible_rect;
     EXPECT_EQ(quadVisibleRect6.height(), 50);
     EXPECT_EQ(quadVisibleRect6.y(), 250);
 
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 100000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 30000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 100000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 30000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullCenterTileNonIntegralSize1)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     childTransform.Translate(100, 100);
 
     // Make the root layer's quad have extent (99.1, 99.1) -> (200.9, 200.9) to make
     // sure it doesn't get culled due to transform rounding.
     gfx::Transform rootTransform;
     rootTransform.Translate(99.1, 99.1);
     rootTransform.Scale(1.018, 1.018);
 
     rootRect = childRect = gfx::Rect(0, 0, 100, 100);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, rootTransform, rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 2u);
 
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 20363, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 20363, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullCenterTileNonIntegralSize2)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     // Make the child's quad slightly smaller than, and centred over, the root layer tile.
     // Verify the child does not cause the quad below to be culled due to rounding.
     childTransform.Translate(100.1, 100.1);
     childTransform.Scale(0.982, 0.982);
 
     gfx::Transform rootTransform;
     rootTransform.Translate(100, 100);
 
     rootRect = childRect = gfx::Rect(0, 0, 100, 100);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, rootTransform, rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 2u);
 
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 19643, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 19643, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullChildLinesUpBottomRight)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     childTransform.Translate(100, 100);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 9u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 40000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 40000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullSubRegion)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     childTransform.Translate(50, 50);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     gfx::Rect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() / 2);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, false, childOpaqueRect, renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 12u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 30000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 10000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 30000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 10000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullSubRegion2)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     childTransform.Translate(50, 10);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     gfx::Rect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() * 3 / 4);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, false, childOpaqueRect, renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 12u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 25000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 15000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 25000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 15000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullSubRegionCheckOvercull)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     childTransform.Translate(50, 49);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     gfx::Rect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() / 2);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, false, childOpaqueRect, renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 13u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 90000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 30000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 10000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 30000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 10000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyNonAxisAlignedQuadsDontOcclude)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     // Use a small rotation so as to not disturb the geometry significantly.
     childTransform.Rotate(1);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), childTransform, childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 13u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 130000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 130000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 // This test requires some explanation: here we are rotating the quads to be culled.
 // The 2x2 tile child layer remains in the top-left corner, unrotated, but the 3x3
 // tile parent layer is rotated by 1 degree. Of the four tiles the child would
 // normally occlude, three will move (slightly) out from under the child layer, and
 // one moves further under the child. Only this last tile should be culled.
 TEST_F(QuadCullerTest, verifyNonAxisAlignedQuadsSafelyCulled)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     // Use a small rotation so as to not disturb the geometry significantly.
     gfx::Transform parentTransform;
     parentTransform.Rotate(1);
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, parentTransform, rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(-100, -100, 1000, 1000));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 12u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 100600, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 29400, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 100600, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 29400, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullOutsideScissorOverTile)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(200, 100, 100, 100));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 1u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 10000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 120000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 10000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 120000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullOutsideScissorOverCulledTile)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(100, 100, 100, 100));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 1u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 10000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 120000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 10000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 120000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullOutsideScissorOverPartialTiles)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(50, 50, 200, 200));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 9u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 40000, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 90000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 40000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 90000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyCullOutsideScissorOverNoTiles)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(500, 500, 100, 100));
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 0u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 130000, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 130000, 1);
 }
 
 TEST_F(QuadCullerTest, verifyWithoutMetrics)
 {
     DECLARE_AND_INITIALIZE_TEST_QUADS
 
     scoped_ptr<TiledLayerImpl> rootLayer = makeLayer(0, gfx::Transform(), rootRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     scoped_ptr<TiledLayerImpl> childLayer = makeLayer(rootLayer.get(), gfx::Transform(), childRect, 1, true, gfx::Rect(), renderSurfaceLayerList);
     TestOcclusionTrackerImpl occlusionTracker(gfx::Rect(50, 50, 200, 200), false);
     LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList);
 
     appendQuads(quadList, sharedStateList, childLayer.get(), it, occlusionTracker);
     appendQuads(quadList, sharedStateList, rootLayer.get(), it, occlusionTracker);
     EXPECT_EQ(quadList.size(), 9u);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnOpaque(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
-    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixelsCulledForDrawing(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_opaque(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_drawn_translucent(), 0, 1);
+    EXPECT_NEAR(occlusionTracker.OverdrawMetrics().pixels_culled_for_drawing(), 0, 1);
 }
 
 }  // namespace
 }  // namespace cc