cc: Chromify the OverdrawMetrics class.

cc/tiled_layer_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/tiled_layer.h"
 
 #include "cc/bitmap_content_layer_updater.h"
 #include "cc/layer_painter.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/prioritized_resource_manager.h"
@@ skipping 212 matching lines @@
     scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
     m_layerTreeHost->setViewportSize(gfx::Size(1000, 1000), gfx::Size(1000, 1000));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
     calcDrawProps(layer);
     updateAndPush(layer, layerImpl);
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // Invalidates part of the top tile...
     layer->invalidateContentRect(gfx::Rect(0, 0, 50, 50));
     // ....but the area is occluded.
     occluded.setOcclusion(gfx::Rect(0, 0, 50, 50));
     calcDrawProps(layer);
     updateAndPush(layer, layerImpl);
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000 + 2500, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000 + 2500, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // We should still have both tiles, as part of the top tile is still unoccluded.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, pushDeletedTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
@@ skipping 199 matching lines @@
     // The tile size is 100x100, so this invalidates one occluded tile, culls it during paint, but prepaints it.
     occluded.setOcclusion(gfx::Rect(0, 0, 100, 100));
 
     layer->setBounds(gfx::Size(100, 100));
     calcDrawProps(layer);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
     updateAndPush(layer, layerImpl);
 
     // We should have the prepainted tile on the impl side, but culled it during paint.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
-    EXPECT_EQ(1, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_EQ(1, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, pushTilesMarkedDirtyDuringPaint)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     // However, during the paint, we invalidate one of the tiles. This should
     // not prevent the tile from being pushed.
@@ skipping 542 matching lines @@
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->drawProperties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
-    EXPECT_EQ(3, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 330000, 1);
+    EXPECT_EQ(3, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     occluded.setOcclusion(gfx::Rect(250, 200, 300, 100));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36-2, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 330000 + 340000, 1);
-    EXPECT_EQ(3 + 2, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 330000 + 340000, 1);
+    EXPECT_EQ(3 + 2, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     occluded.setOcclusion(gfx::Rect(250, 250, 300, 100));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 330000 + 340000 + 360000, 1);
-    EXPECT_EQ(3 + 2, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 330000 + 340000 + 360000, 1);
+    EXPECT_EQ(3 + 2, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     m_layerTreeHost->setViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
     layer->setBounds(gfx::Size(600, 600));
     calcDrawProps(layer);
 
     // The partially occluded tiles (by the 150 occlusion height) are visible beyond the occlusion, so not culled.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 360);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 360);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(24-3, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 210000, 1);
-    EXPECT_EQ(3, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 210000, 1);
+    EXPECT_EQ(3, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // Now the visible region stops at the edge of the occlusion so the partly visible tiles become fully occluded.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 350);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 350);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(24-6, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 210000 + 180000, 1);
-    EXPECT_EQ(3 + 6, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 210000 + 180000, 1);
+    EXPECT_EQ(3 + 6, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // Now the visible region is even smaller than the occlusion, it should have the same result.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 340);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 340);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(24-6, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 210000 + 180000 + 180000, 1);
-    EXPECT_EQ(3 + 6 + 6, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 210000 + 180000 + 180000, 1);
+    EXPECT_EQ(3 + 6 + 6, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
 }
 
 TEST_F(TiledLayerTest, tilesNotPaintedWithoutInvalidation)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     m_layerTreeHost->setViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
     layer->setBounds(gfx::Size(600, 600));
     calcDrawProps(layer);
 
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 600);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 600);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
     {
         updateTextures();
     }
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
-    EXPECT_EQ(3, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 330000, 1);
+    EXPECT_EQ(3, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     // Repaint without marking it dirty. The 3 culled tiles will be pre-painted now.
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(3, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
-    EXPECT_EQ(6, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 330000, 1);
+    EXPECT_EQ(6, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndTransforms)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     // This makes sure the painting works when the occluded region (in screen space)
     // is transformed differently than the layer.
     m_layerTreeHost->setViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
     layer->setBounds(gfx::Size(600, 600));
     calcDrawProps(layer);
     gfx::Transform screenTransform;
     screenTransform.Scale(0.5, 0.5);
     layer->drawProperties().screen_space_transform = screenTransform;
     layer->drawProperties().target_space_transform = screenTransform;
 
     occluded.setOcclusion(gfx::Rect(100, 100, 150, 50));
     layer->drawProperties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
-    EXPECT_EQ(3, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 330000, 1);
+    EXPECT_EQ(3, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndScaling)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
@@ skipping 16 matching lines @@
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     // The content is half the size of the layer (so the number of tiles is fewer).
     // In this case, the content is 300x300, and since the tile size is 100, the
     // number of tiles 3x3.
     EXPECT_EQ(9, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 90000, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 90000, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // This makes sure the painting works when the content space is scaled to
     // a different layer space. In this case the occluded region catches the
     // blown up tiles.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 200));
     layer->drawProperties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->bounds());
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(9-1, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 90000 + 80000, 1);
-    EXPECT_EQ(1, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 90000 + 80000, 1);
+    EXPECT_EQ(1, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // This makes sure content scaling and transforms work together.
     gfx::Transform screenTransform;
     screenTransform.Scale(0.5, 0.5);
     layer->drawProperties().screen_space_transform = screenTransform;
     layer->drawProperties().target_space_transform = screenTransform;
 
     occluded.setOcclusion(gfx::Rect(100, 100, 150, 100));
 
     gfx::Rect layerBoundsRect(gfx::Point(), layer->bounds());
     layer->drawProperties().drawable_content_rect = gfx::ToEnclosingRect(gfx::ScaleRect(layerBoundsRect, 0.5));
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(9-1, layer->fakeLayerUpdater()->updateCount());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 90000 + 80000 + 80000, 1);
-    EXPECT_EQ(1 + 1, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 90000 + 80000 + 80000, 1);
+    EXPECT_EQ(1 + 1, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
     m_layerTreeHost->setViewportSize(gfx::Size(1000, 1000), gfx::Size(1000, 1000));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles in various ways.
@@ skipping 11 matching lines @@
 
     // If the layer doesn't paint opaque content, then the visibleContentOpaqueRegion should be empty.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(contentBounds);
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 20000, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 20000, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // visibleContentOpaqueRegion should match the visible part of what is painted opaque.
     opaquePaintRect = gfx::Rect(10, 10, 90, 190);
     layer->fakeLayerUpdater()->setOpaquePaintRect(opaquePaintRect);
     layer->invalidateContentRect(contentBounds);
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 20000 * 2, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 20000 * 2, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 17100, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000 + 20000 - 17100, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // If we paint again without invalidating, the same stuff should be opaque.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 20000 * 2, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 20000 * 2, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 17100, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000 + 20000 - 17100, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // If we repaint a non-opaque part of the tile, then it shouldn't lose its opaque-ness. And other tiles should
     // not be affected.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(0, 0, 1, 1));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 20000 * 2 + 1, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100 + 1, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 20000 * 2 + 1, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 17100, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000 + 20000 - 17100 + 1, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // If we repaint an opaque part of the tile, then it should lose its opaque-ness. But other tiles should still
     // not be affected.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(10, 10, 1, 1));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(gfx::Rect(10, 100, 90, 100), visibleBounds).ToString(), opaqueContents.ToString());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 20000 * 2 + 1  + 1, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100 + 1 + 1, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 20000 * 2 + 1  + 1, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 17100, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 20000 + 20000 - 17100 + 1 + 1, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
-TEST_F(TiledLayerTest, pixelsPaintedMetrics)
+TEST_F(TiledLayerTest, pixels_paintedMetrics)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
     m_layerTreeHost->setViewportSize(gfx::Size(1000, 1000), gfx::Size(1000, 1000));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles in various ways.
 
     gfx::Rect opaquePaintRect;
     Region opaqueContents;
 
     gfx::Rect contentBounds = gfx::Rect(0, 0, 100, 300);
     layer->setBounds(contentBounds.size());
     calcDrawProps(layer);
 
     // Invalidates and paints the whole layer.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(contentBounds);
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 30000, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 30000, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 30000, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 30000, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 
     // Invalidates an area on the top and bottom tile, which will cause us to paint the tile in the middle,
     // even though it is not dirty and will not be uploaded.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(0, 0, 1, 1));
     layer->invalidateContentRect(gfx::Rect(50, 200, 10, 10));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     // The middle tile was painted even though not invalidated.
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsPainted(), 30000 + 60 * 210, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_painted(), 30000 + 60 * 210, 1);
     // The pixels uploaded will not include the non-invalidated tile in the middle.
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedOpaque(), 0, 1);
-    EXPECT_NEAR(occluded.OverdrawMetrics().pixelsUploadedTranslucent(), 30000 + 1 + 100, 1);
-    EXPECT_EQ(0, occluded.OverdrawMetrics().tilesCulledForUpload());
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_opaque(), 0, 1);
+    EXPECT_NEAR(occluded.OverdrawMetrics().pixels_uploaded_translucent(), 30000 + 1 + 100, 1);
+    EXPECT_EQ(0, occluded.OverdrawMetrics().tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, dontAllocateContentsWhenTargetSurfaceCantBeAllocated)
 {
     // Tile size is 100x100.
     gfx::Rect rootRect(0, 0, 300, 200);
     gfx::Rect childRect(0, 0, 300, 100);
     gfx::Rect child2Rect(0, 100, 300, 100);
 
     scoped_refptr<FakeTiledLayer> root = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
@@ skipping 232 matching lines @@
 
     // Invalidate the entire layer in layer space. When painting, the rect given to webkit should match the layer's bounds.
     layer->setNeedsDisplayRect(layerRect);
     layer->update(*m_queue.get(), 0, NULL);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 }  // namespace
 }  // namespace cc