cc: Chromify the OverdrawMetrics class.

Style-only change. Make the OverdrawMetrics class use chromium style.

R=jamesr,enne


Review URL: https://chromiumcodereview.appspot.com/12728002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@187129 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 440 insertions, 374 deletions

diff --git a/cc/layer_tree_host.cc b/cc/layer_tree_host.cc
index e6616c7..7a5b6e7 100644
--- a/cc/layer_tree_host.cc
+++ b/cc/layer_tree_host.cc
@@ -671,8 +671,8 @@ void LayerTreeHost::prioritizeTextures(const LayerList& renderSurfaceLayerList,
     setPrioritiesForLayers(renderSurfaceLayerList);
     setPrioritiesForSurfaces(memoryForRenderSurfacesMetric);
 
-    metrics.didUseContentsTextureMemoryBytes(m_contentsTextureManager->memoryAboveCutoffBytes());
-    metrics.didUseRenderSurfaceTextureMemoryBytes(memoryForRenderSurfacesMetric);
+    metrics.DidUseContentsTextureMemoryBytes(m_contentsTextureManager->memoryAboveCutoffBytes());
+    metrics.DidUseRenderSurfaceTextureMemoryBytes(memoryForRenderSurfacesMetric);
 
     m_contentsTextureManager->prioritizeTextures();
 }
@@ -755,7 +755,7 @@ bool LayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList,
         occlusionTracker.LeaveLayer(it);
     }
 
-    occlusionTracker.OverdrawMetrics().recordMetrics(this);
+    occlusionTracker.OverdrawMetrics().RecordMetrics(this);
 
     return needMoreUpdates;
 }
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 876e913..b8093ce 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -546,7 +546,7 @@ bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
     }
 
     if (drawFrame)
-        occlusionTracker.OverdrawMetrics().recordMetrics(this);
+        occlusionTracker.OverdrawMetrics().RecordMetrics(this);
 
     removeRenderPasses(CullRenderPassesWithNoQuads(), frame);
     m_renderer->DecideRenderPassAllocationsForFrame(frame.renderPasses);
diff --git a/cc/occlusion_tracker.cc b/cc/occlusion_tracker.cc
index 89ae8b9..15c4b79 100644
--- a/cc/occlusion_tracker.cc
+++ b/cc/occlusion_tracker.cc
@@ -19,7 +19,7 @@ template <typename LayerType, typename RenderSurfaceType>
 OcclusionTrackerBase<LayerType, RenderSurfaceType>::OcclusionTrackerBase(
     gfx::Rect screen_space_clip_rect, bool record_metrics_for_frame)
     : screen_space_clip_rect_(screen_space_clip_rect),
-      overdraw_metrics_(OverdrawMetrics::create(record_metrics_for_frame)),
+      overdraw_metrics_(OverdrawMetrics::Create(record_metrics_for_frame)),
       occluding_screen_space_rects_(NULL),
       non_occluding_screen_space_rects_(NULL) {}
 
diff --git a/cc/overdraw_metrics.cc b/cc/overdraw_metrics.cc
index c1ab20f..0ed58d1 100644
--- a/cc/overdraw_metrics.cc
+++ b/cc/overdraw_metrics.cc
@@ -15,205 +15,253 @@
 
 namespace cc {
 
-OverdrawMetrics::OverdrawMetrics(bool recordMetricsForFrame)
-    : m_recordMetricsForFrame(recordMetricsForFrame)
-    , m_pixelsPainted(0)
-    , m_pixelsUploadedOpaque(0)
-    , m_pixelsUploadedTranslucent(0)
-    , m_tilesCulledForUpload(0)
-    , m_contentsTextureUseBytes(0)
-    , m_renderSurfaceTextureUseBytes(0)
-    , m_pixelsDrawnOpaque(0)
-    , m_pixelsDrawnTranslucent(0)
-    , m_pixelsCulledForDrawing(0)
-{
-}
-
-static inline float wedgeProduct(const gfx::PointF& p1, const gfx::PointF& p2)
-{
-    return p1.x() * p2.y() - p1.y() * p2.x();
+OverdrawMetrics::OverdrawMetrics(bool record_metrics_for_frame)
+    : record_metrics_for_frame_(record_metrics_for_frame),
+      pixels_painted_(0),
+      pixels_uploaded_opaque_(0),
+      pixels_uploaded_translucent_(0),
+      tiles_culled_for_upload_(0),
+      contents_texture_use_bytes_(0),
+      render_surface_texture_use_bytes_(0),
+      pixels_drawn_opaque_(0),
+      pixels_drawn_translucent_(0),
+      pixels_culled_for_drawing_(0) {}
+
+static inline float WedgeProduct(gfx::PointF p1, gfx::PointF p2) {
+  return p1.x() * p2.y() - p1.y() * p2.x();
 }
 
 // Calculates area of an arbitrary convex polygon with up to 8 points.
-static inline float polygonArea(const gfx::PointF points[8], int numPoints)
-{
-    if (numPoints < 3)
-        return 0;
-
-    float area = 0;
-    for (int i = 0; i < numPoints; ++i)
-        area += wedgeProduct(points[i], points[(i+1)%numPoints]);
-    return fabs(0.5f * area);
+static inline float PolygonArea(gfx::PointF points[8], int num_points) {
+  if (num_points < 3)
+    return 0;
+
+  float area = 0;
+  for (int i = 0; i < num_points; ++i)
+    area += WedgeProduct(points[i], points[(i+1)%num_points]);
+  return fabs(0.5f * area);
 }
 
-// Takes a given quad, maps it by the given transformation, and gives the area of the resulting polygon.
-static inline float areaOfMappedQuad(const gfx::Transform& transform, const gfx::QuadF& quad)
-{
-    gfx::PointF clippedQuad[8];
-    int numVerticesInClippedQuad = 0;
-    MathUtil::mapClippedQuad(transform, quad, clippedQuad, numVerticesInClippedQuad);
-    return polygonArea(clippedQuad, numVerticesInClippedQuad);
+// Takes a given quad, maps it by the given transformation, and gives the area
+// of the resulting polygon.
+static inline float AreaOfMappedQuad(const gfx::Transform& transform,
+                                     const gfx::QuadF& quad) {
+  gfx::PointF clippedQuad[8];
+  int num_vertices_in_clipped_quad = 0;
+  MathUtil::mapClippedQuad(transform,
+                           quad,
+                           clippedQuad,
+                           num_vertices_in_clipped_quad);
+  return PolygonArea(clippedQuad, num_vertices_in_clipped_quad);
 }
 
-void OverdrawMetrics::didPaint(const gfx::Rect& paintedRect)
-{
-    if (!m_recordMetricsForFrame)
-        return;
+void OverdrawMetrics::DidPaint(gfx::Rect painted_rect) {
+  if (!record_metrics_for_frame_)
+    return;
 
-    m_pixelsPainted += static_cast<float>(paintedRect.width()) * paintedRect.height();
+  pixels_painted_ +=
+      static_cast<float>(painted_rect.width()) * painted_rect.height();
 }
 
-void OverdrawMetrics::didCullTilesForUpload(int count)
-{
-    if (m_recordMetricsForFrame)
-        m_tilesCulledForUpload += count;
+void OverdrawMetrics::DidCullTilesForUpload(int count) {
+  if (record_metrics_for_frame_)
+    tiles_culled_for_upload_ += count;
 }
 
-void OverdrawMetrics::didUpload(const gfx::Transform& transformToTarget, const gfx::Rect& uploadRect, const gfx::Rect& opaqueRect)
-{
-    if (!m_recordMetricsForFrame)
-        return;
-
-    float uploadArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(uploadRect));
-    float uploadOpaqueArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(gfx::IntersectRects(opaqueRect, uploadRect)));
-
-    m_pixelsUploadedOpaque += uploadOpaqueArea;
-    m_pixelsUploadedTranslucent += uploadArea - uploadOpaqueArea;
+void OverdrawMetrics::DidUpload(const gfx::Transform& transform_to_target,
+                                gfx::Rect upload_rect,
+                                gfx::Rect opaque_rect) {
+  if (!record_metrics_for_frame_)
+    return;
+
+  float upload_area =
+      AreaOfMappedQuad(transform_to_target, gfx::QuadF(upload_rect));
+  float upload_opaque_area =
+      AreaOfMappedQuad(transform_to_target,
+                       gfx::QuadF(gfx::IntersectRects(opaque_rect,
+                                                      upload_rect)));
+
+  pixels_uploaded_opaque_ += upload_opaque_area;
+  pixels_uploaded_translucent_ += upload_area - upload_opaque_area;
 }
 
-void OverdrawMetrics::didUseContentsTextureMemoryBytes(size_t contentsTextureUseBytes)
-{
-    if (!m_recordMetricsForFrame)
-        return;
+void OverdrawMetrics::DidUseContentsTextureMemoryBytes(
+    size_t contents_texture_use_bytes) {
+  if (!record_metrics_for_frame_)
+    return;
 
-    m_contentsTextureUseBytes += contentsTextureUseBytes;
+  contents_texture_use_bytes_ += contents_texture_use_bytes;
 }
 
-void OverdrawMetrics::didUseRenderSurfaceTextureMemoryBytes(size_t renderSurfaceUseBytes)
-{
-    if (!m_recordMetricsForFrame)
-        return;
+void OverdrawMetrics::DidUseRenderSurfaceTextureMemoryBytes(
+    size_t render_surface_use_bytes) {
+  if (!record_metrics_for_frame_)
+    return;
 
-    m_renderSurfaceTextureUseBytes += renderSurfaceUseBytes;
+  render_surface_texture_use_bytes_ += render_surface_use_bytes;
 }
 
-void OverdrawMetrics::didCullForDrawing(const gfx::Transform& transformToTarget, const gfx::Rect& beforeCullRect, const gfx::Rect& afterCullRect)
-{
-    if (!m_recordMetricsForFrame)
-        return;
+void OverdrawMetrics::DidCullForDrawing(
+    const gfx::Transform& transform_to_target,
+    gfx::Rect before_cull_rect,
+    gfx::Rect after_cull_rect) {
+  if (!record_metrics_for_frame_)
+    return;
 
-    float beforeCullArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(beforeCullRect));
-    float afterCullArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(afterCullRect));
+  float before_cull_area =
+      AreaOfMappedQuad(transform_to_target, gfx::QuadF(before_cull_rect));
+  float after_cull_area =
+      AreaOfMappedQuad(transform_to_target, gfx::QuadF(after_cull_rect));
 
-    m_pixelsCulledForDrawing += beforeCullArea - afterCullArea;
+  pixels_culled_for_drawing_ += before_cull_area - after_cull_area;
 }
 
-void OverdrawMetrics::didDraw(const gfx::Transform& transformToTarget, const gfx::Rect& afterCullRect, const gfx::Rect& opaqueRect)
-{
-    if (!m_recordMetricsForFrame)
-        return;
-
-    float afterCullArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(afterCullRect));
-    float afterCullOpaqueArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(gfx::IntersectRects(opaqueRect, afterCullRect)));
-
-    m_pixelsDrawnOpaque += afterCullOpaqueArea;
-    m_pixelsDrawnTranslucent += afterCullArea - afterCullOpaqueArea;
+void OverdrawMetrics::DidDraw(const gfx::Transform& transform_to_target,
+                              gfx::Rect after_cull_rect,
+                              gfx::Rect opaque_rect) {
+  if (!record_metrics_for_frame_)
+    return;
+
+  float after_cull_area =
+      AreaOfMappedQuad(transform_to_target, gfx::QuadF(after_cull_rect));
+  float after_cull_opaque_area =
+      AreaOfMappedQuad(transform_to_target,
+                       gfx::QuadF(gfx::IntersectRects(opaque_rect,
+                                                      after_cull_rect)));
+
+  pixels_drawn_opaque_ += after_cull_opaque_area;
+  pixels_drawn_translucent_ += after_cull_area - after_cull_opaque_area;
 }
 
-void OverdrawMetrics::recordMetrics(const LayerTreeHost* layerTreeHost) const
-{
-    if (m_recordMetricsForFrame)
-        recordMetricsInternal<LayerTreeHost>(UpdateAndCommit, layerTreeHost);
+void OverdrawMetrics::RecordMetrics(
+    const LayerTreeHost* layer_tree_host) const {
+  if (record_metrics_for_frame_)
+    RecordMetricsInternal<LayerTreeHost>(UpdateAndCommit, layer_tree_host);
 }
 
-void OverdrawMetrics::recordMetrics(const LayerTreeHostImpl* layerTreeHost) const
-{
-    if (m_recordMetricsForFrame)
-        recordMetricsInternal<LayerTreeHostImpl>(DrawingToScreen, layerTreeHost);
+void OverdrawMetrics::RecordMetrics(
+    const LayerTreeHostImpl* layer_tree_host_impl) const {
+  if (record_metrics_for_frame_) {
+    RecordMetricsInternal<LayerTreeHostImpl>(DrawingToScreen,
+                                             layer_tree_host_impl);
+  }
 }
 
-static gfx::Size DeviceViewportSize(const LayerTreeHost* host) { return host->deviceViewportSize(); }
-static gfx::Size DeviceViewportSize(const LayerTreeHostImpl* host_impl) { return host_impl->DeviceViewportSize(); }
-
-template<typename LayerTreeHostType>
-void OverdrawMetrics::recordMetricsInternal(MetricsType metricsType, const LayerTreeHostType* layerTreeHost) const
-{
-    // This gives approximately 10x the percentage of pixels to fill the viewport once.
-    float normalization = 1000.f / (DeviceViewportSize(layerTreeHost).width() * DeviceViewportSize(layerTreeHost).height());
-    // This gives approximately 100x the percentage of tiles to fill the viewport once, if all tiles were 256x256.
-    float tileNormalization = 10000.f / (DeviceViewportSize(layerTreeHost).width() / 256.f * DeviceViewportSize(layerTreeHost).height() / 256.f);
-    // This gives approximately 10x the percentage of bytes to fill the viewport once, assuming 4 bytes per pixel.
-    float byteNormalization = normalization / 4;
+static gfx::Size DeviceViewportSize(const LayerTreeHost* host) {
+  return host->deviceViewportSize();
+}
+static gfx::Size DeviceViewportSize(const LayerTreeHostImpl* host_impl) {
+  return host_impl->DeviceViewportSize();
+}
 
-    switch (metricsType) {
+template <typename LayerTreeHostType>
+void OverdrawMetrics::RecordMetricsInternal(
+    MetricsType metrics_type,
+    const LayerTreeHostType* layer_tree_host) const {
+  // This gives approximately 10x the percentage of pixels to fill the viewport
+  // once.
+  float normalization = 1000.f / (DeviceViewportSize(layer_tree_host).width() *
+                                  DeviceViewportSize(layer_tree_host).height());
+  // This gives approximately 100x the percentage of tiles to fill the viewport
+  // once, if all tiles were 256x256.
+  float tile_normalization =
+      10000.f / (DeviceViewportSize(layer_tree_host).width() / 256.f *
+                 DeviceViewportSize(layer_tree_host).height() / 256.f);
+  // This gives approximately 10x the percentage of bytes to fill the viewport
+  // once, assuming 4 bytes per pixel.
+  float byte_normalization = normalization / 4;
+
+  switch (metrics_type) {
     case DrawingToScreen: {
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.pixelCountOpaque_Draw",
-            static_cast<int>(normalization * m_pixelsDrawnOpaque),
-            100, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.pixelCountTranslucent_Draw",
-            static_cast<int>(normalization * m_pixelsDrawnTranslucent),
-            100, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.pixelCountCulled_Draw",
-            static_cast<int>(normalization * m_pixelsCulledForDrawing),
-            100, 1000000, 50);
-
-        TRACE_COUNTER_ID1("cc", "DrawPixelsCulled", layerTreeHost, m_pixelsCulledForDrawing);
-        TRACE_EVENT2("cc", "OverdrawMetrics", "PixelsDrawnOpaque", m_pixelsDrawnOpaque, "PixelsDrawnTranslucent", m_pixelsDrawnTranslucent);
-        break;
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.pixelCountOpaque_Draw",
+          static_cast<int>(normalization * pixels_drawn_opaque_),
+          100, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.pixelCountTranslucent_Draw",
+          static_cast<int>(normalization * pixels_drawn_translucent_),
+          100, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.pixelCountCulled_Draw",
+          static_cast<int>(normalization * pixels_culled_for_drawing_),
+          100, 1000000, 50);
+
+      TRACE_COUNTER_ID1("cc",
+                        "DrawPixelsCulled",
+                        layer_tree_host,
+                        pixels_culled_for_drawing_);
+      TRACE_EVENT2("cc",
+                   "OverdrawMetrics",
+                   "PixelsDrawnOpaque",
+                   pixels_drawn_opaque_,
+                   "PixelsDrawnTranslucent",
+                   pixels_drawn_translucent_);
+      break;
     }
     case UpdateAndCommit: {
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.pixelCountPainted",
-            static_cast<int>(normalization * m_pixelsPainted),
-            100, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.pixelCountOpaque_Upload",
-            static_cast<int>(normalization * m_pixelsUploadedOpaque),
-            100, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.pixelCountTranslucent_Upload",
-            static_cast<int>(normalization * m_pixelsUploadedTranslucent),
-            100, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.tileCountCulled_Upload",
-            static_cast<int>(tileNormalization * m_tilesCulledForUpload),
-            100, 10000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.renderSurfaceTextureBytes_ViewportScaled",
-            static_cast<int>(
-                byteNormalization * m_renderSurfaceTextureUseBytes),
-            10, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.renderSurfaceTextureBytes_Unscaled",
-            static_cast<int>(m_renderSurfaceTextureUseBytes / 1000),
-            1000, 100000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.contentsTextureBytes_ViewportScaled",
-            static_cast<int>(byteNormalization * m_contentsTextureUseBytes),
-            10, 1000000, 50);
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Renderer4.contentsTextureBytes_Unscaled",
-            static_cast<int>(m_contentsTextureUseBytes / 1000),
-            1000, 100000000, 50);
-
-        {
-            TRACE_COUNTER_ID1("cc", "UploadTilesCulled", layerTreeHost, m_tilesCulledForUpload);
-            TRACE_EVENT2("cc", "OverdrawMetrics", "PixelsUploadedOpaque", m_pixelsUploadedOpaque, "PixelsUploadedTranslucent", m_pixelsUploadedTranslucent);
-        }
-        {
-            // This must be in a different scope than the TRACE_EVENT2 above.
-            TRACE_EVENT1("cc", "OverdrawPaintMetrics", "PixelsPainted", m_pixelsPainted);
-        }
-        {
-            // This must be in a different scope than the TRACE_EVENTs above.
-            TRACE_EVENT2("cc", "OverdrawPaintMetrics", "ContentsTextureBytes", m_contentsTextureUseBytes, "RenderSurfaceTextureBytes", m_renderSurfaceTextureUseBytes);
-        }
-        break;
-    }
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.pixelCountPainted",
+          static_cast<int>(normalization * pixels_painted_),
+          100, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.pixelCountOpaque_Upload",
+          static_cast<int>(normalization * pixels_uploaded_opaque_),
+          100, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.pixelCountTranslucent_Upload",
+          static_cast<int>(normalization * pixels_uploaded_translucent_),
+          100, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.tileCountCulled_Upload",
+          static_cast<int>(tile_normalization * tiles_culled_for_upload_),
+          100, 10000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.renderSurfaceTextureBytes_ViewportScaled",
+          static_cast<int>(
+              byte_normalization * render_surface_texture_use_bytes_),
+          10, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.renderSurfaceTextureBytes_Unscaled",
+          static_cast<int>(render_surface_texture_use_bytes_ / 1000),
+          1000, 100000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.contentsTextureBytes_ViewportScaled",
+          static_cast<int>(byte_normalization * contents_texture_use_bytes_),
+          10, 1000000, 50);
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.contentsTextureBytes_Unscaled",
+          static_cast<int>(contents_texture_use_bytes_ / 1000),
+          1000, 100000000, 50); {
+        TRACE_COUNTER_ID1("cc",
+                          "UploadTilesCulled",
+                          layer_tree_host,
+                          tiles_culled_for_upload_);
+        TRACE_EVENT2("cc",
+                     "OverdrawMetrics",
+                     "PixelsUploadedOpaque",
+                     pixels_uploaded_opaque_,
+                     "PixelsUploadedTranslucent",
+                     pixels_uploaded_translucent_);
+      }
+      {
+        // This must be in a different scope than the TRACE_EVENT2 above.
+        TRACE_EVENT1("cc",
+                     "OverdrawPaintMetrics",
+                     "PixelsPainted",
+                     pixels_painted_);
+      }
+      {
+        // This must be in a different scope than the TRACE_EVENTs above.
+        TRACE_EVENT2("cc",
+                     "OverdrawPaintMetrics",
+                     "ContentsTextureBytes",
+                     contents_texture_use_bytes_,
+                     "RenderSurfaceTextureBytes",
+                     render_surface_texture_use_bytes_);
+      }
+      break;
     }
+  }
 }
 
 }  // namespace cc
diff --git a/cc/overdraw_metrics.h b/cc/overdraw_metrics.h
index 81595e7..f9ac091 100644
--- a/cc/overdraw_metrics.h
+++ b/cc/overdraw_metrics.h
@@ -5,6 +5,7 @@
 #ifndef CC_OVERDRAW_METRICS_H_
 #define CC_OVERDRAW_METRICS_H_
 
+#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace gfx {
@@ -16,82 +17,99 @@ namespace cc {
 class LayerTreeHost;
 class LayerTreeHostImpl;
 
-// FIXME: compute overdraw metrics only occasionally, not every frame.
 class OverdrawMetrics {
-public:
-    static scoped_ptr<OverdrawMetrics> create(bool recordMetricsForFrame) { return make_scoped_ptr(new OverdrawMetrics(recordMetricsForFrame)); }
-
-    // These methods are used for saving metrics during update/commit.
-
-    // Record pixels painted by WebKit into the texture updater, but does not mean the pixels were rasterized in main memory.
-    void didPaint(const gfx::Rect& paintedRect);
-    // Records that an invalid tile was culled and did not need to be painted/uploaded, and did not contribute to other tiles needing to be painted.
-    void didCullTilesForUpload(int count);
-    // Records pixels that were uploaded to texture memory.
-    void didUpload(const gfx::Transform& transformToTarget, const gfx::Rect& uploadRect, const gfx::Rect& opaqueRect);
-    // Record contents texture(s) behind present using the given number of bytes.
-    void didUseContentsTextureMemoryBytes(size_t contentsTextureUseBytes);
-    // Record RenderSurfaceImpl texture(s) being present using the given number of bytes.
-    void didUseRenderSurfaceTextureMemoryBytes(size_t renderSurfaceUseBytes);
-
-    // These methods are used for saving metrics during draw.
-
-    // Record pixels that were not drawn to screen.
-    void didCullForDrawing(const gfx::Transform& transformToTarget, const gfx::Rect& beforeCullRect, const gfx::Rect& afterCullRect);
-    // Record pixels that were drawn to screen.
-    void didDraw(const gfx::Transform& transformToTarget, const gfx::Rect& afterCullRect, const gfx::Rect& opaqueRect);
-
-    void recordMetrics(const LayerTreeHost*) const;
-    void recordMetrics(const LayerTreeHostImpl*) const;
-
-    // Accessors for tests.
-    float pixelsDrawnOpaque() const { return m_pixelsDrawnOpaque; }
-    float pixelsDrawnTranslucent() const { return m_pixelsDrawnTranslucent; }
-    float pixelsCulledForDrawing() const { return m_pixelsCulledForDrawing; }
-    float pixelsPainted() const { return m_pixelsPainted; }
-    float pixelsUploadedOpaque() const { return m_pixelsUploadedOpaque; }
-    float pixelsUploadedTranslucent() const { return m_pixelsUploadedTranslucent; }
-    int tilesCulledForUpload() const { return m_tilesCulledForUpload; }
-
-private:
-    enum MetricsType {
-        UpdateAndCommit,
-        DrawingToScreen
-    };
-
-    explicit OverdrawMetrics(bool recordMetricsForFrame);
-
-    template<typename LayerTreeHostType>
-    void recordMetricsInternal(MetricsType, const LayerTreeHostType*) const;
-
-    // When false this class is a giant no-op.
-    bool m_recordMetricsForFrame;
-
-    // These values are used for saving metrics during update/commit.
-
-    // Count of pixels that were painted due to invalidation.
-    float m_pixelsPainted;
-    // Count of pixels uploaded to textures and known to be opaque.
-    float m_pixelsUploadedOpaque;
-    // Count of pixels uploaded to textures and not known to be opaque.
-    float m_pixelsUploadedTranslucent;
-    // Count of tiles that were invalidated but not uploaded.
-    int m_tilesCulledForUpload;
-    // Count the number of bytes in contents textures.
-    unsigned long long m_contentsTextureUseBytes;
-    // Count the number of bytes in RenderSurfaceImpl textures.
-    unsigned long long m_renderSurfaceTextureUseBytes;
-
-    // These values are used for saving metrics during draw.
-
-    // Count of pixels that are opaque (and thus occlude). Ideally this is no more than wiewport width x height.
-    float m_pixelsDrawnOpaque;
-    // Count of pixels that are possibly translucent, and cannot occlude.
-    float m_pixelsDrawnTranslucent;
-    // Count of pixels not drawn as they are occluded by somthing opaque.
-    float m_pixelsCulledForDrawing;
+ public:
+  static scoped_ptr<OverdrawMetrics> Create(bool record_metrics_for_frame) {
+    return make_scoped_ptr(new OverdrawMetrics(record_metrics_for_frame));
+ }
+
+  // These methods are used for saving metrics during update/commit.
+
+  // Record pixels painted by WebKit into the texture updater, but does not mean
+  // the pixels were rasterized in main memory.
+  void DidPaint(gfx::Rect painted_rect);
+  // Records that an invalid tile was culled and did not need to be
+  // painted/uploaded, and did not contribute to other tiles needing to be
+  // painted.
+  void DidCullTilesForUpload(int count);
+  // Records pixels that were uploaded to texture memory.
+  void DidUpload(const gfx::Transform& transform_to_target,
+                 gfx::Rect upload_rect,
+                 gfx::Rect opaque_rect);
+  // Record contents texture(s) behind present using the given number of bytes.
+  void DidUseContentsTextureMemoryBytes(size_t contents_texture_use_bytes);
+  // Record RenderSurfaceImpl texture(s) being present using the given number of
+  // bytes.
+  void DidUseRenderSurfaceTextureMemoryBytes(size_t render_surface_use_bytes);
+
+  // These methods are used for saving metrics during draw.
+
+  // Record pixels that were not drawn to screen.
+  void DidCullForDrawing(const gfx::Transform& transform_to_target,
+                         gfx::Rect before_cull_rect,
+                         gfx::Rect after_cull_rect);
+  // Record pixels that were drawn to screen.
+  void DidDraw(const gfx::Transform& transform_to_target,
+               gfx::Rect after_cull_rect,
+               gfx::Rect opaque_rect);
+
+  void RecordMetrics(const LayerTreeHost* layer_tree_host) const;
+  void RecordMetrics(const LayerTreeHostImpl* layer_tree_host_impl) const;
+
+  // Accessors for tests.
+  float pixels_drawn_opaque() const { return pixels_drawn_opaque_; }
+  float pixels_drawn_translucent() const { return pixels_drawn_translucent_; }
+  float pixels_culled_for_drawing() const { return pixels_culled_for_drawing_; }
+  float pixels_painted() const { return pixels_painted_; }
+  float pixels_uploaded_opaque() const { return pixels_uploaded_opaque_; }
+  float pixels_uploaded_translucent() const {
+    return pixels_uploaded_translucent_;
+  }
+  int tiles_culled_for_upload() const { return tiles_culled_for_upload_; }
+
+ private:
+  enum MetricsType {
+    UpdateAndCommit,
+    DrawingToScreen
+  };
+
+  explicit OverdrawMetrics(bool record_metrics_for_frame);
+
+  template <typename LayerTreeHostType>
+  void RecordMetricsInternal(MetricsType metrics_type,
+                             const LayerTreeHostType* layer_tree_host) const;
+
+  // When false this class is a giant no-op.
+  bool record_metrics_for_frame_;
+
+  // These values are used for saving metrics during update/commit.
+
+  // Count of pixels that were painted due to invalidation.
+  float pixels_painted_;
+  // Count of pixels uploaded to textures and known to be opaque.
+  float pixels_uploaded_opaque_;
+  // Count of pixels uploaded to textures and not known to be opaque.
+  float pixels_uploaded_translucent_;
+  // Count of tiles that were invalidated but not uploaded.
+  int tiles_culled_for_upload_;
+  // Count the number of bytes in contents textures.
+  unsigned long long contents_texture_use_bytes_;
+  // Count the number of bytes in RenderSurfaceImpl textures.
+  unsigned long long render_surface_texture_use_bytes_;
+
+  // These values are used for saving metrics during draw.
+
+  // Count of pixels that are opaque (and thus occlude). Ideally this is no more
+  // than wiewport width x height.
+  float pixels_drawn_opaque_;
+  // Count of pixels that are possibly translucent, and cannot occlude.
+  float pixels_drawn_translucent_;
+  // Count of pixels not drawn as they are occluded by somthing opaque.
+  float pixels_culled_for_drawing_;
+
+  DISALLOW_COPY_AND_ASSIGN(OverdrawMetrics);
 };
 
-} // namespace cc
+}  // namespace cc
 
 #endif  // CC_OVERDRAW_METRICS_H_
diff --git a/cc/quad_culler.cc b/cc/quad_culler.cc
index 02f4364..cc070e4 100644
--- a/cc/quad_culler.cc
+++ b/cc/quad_culler.cc
@@ -41,9 +41,9 @@ static inline bool appendQuadInternal(scoped_ptr<DrawQuad> drawQuad, const gfx::
     if (keepQuad)
         drawQuad->visible_rect = culledRect;
 
-    occlusionTracker.OverdrawMetrics().didCullForDrawing(drawQuad->quadTransform(), drawQuad->rect, culledRect);
+    occlusionTracker.OverdrawMetrics().DidCullForDrawing(drawQuad->quadTransform(), drawQuad->rect, culledRect);
     gfx::Rect opaqueDrawRect = drawQuad->opacity() == 1.0f ? drawQuad->opaque_rect : gfx::Rect();
-    occlusionTracker.OverdrawMetrics().didDraw(drawQuad->quadTransform(), culledRect, opaqueDrawRect);
+    occlusionTracker.OverdrawMetrics().DidDraw(drawQuad->quadTransform(), culledRect, opaqueDrawRect);
 
     if (keepQuad) {
         if (createDebugBorderQuads && !drawQuad->IsDebugQuad() && drawQuad->visible_rect != drawQuad->rect) {
diff --git a/cc/quad_culler_unittest.cc b/cc/quad_culler_unittest.cc
index 7e222dd..edf3c89 100644
--- a/cc/quad_culler_unittest.cc
+++ b/cc/quad_culler_unittest.cc
@@ -124,9 +124,9 @@ TEST_F(QuadCullerTest, verifyNoCulling)
     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)
@@ -141,9 +141,9 @@ TEST_F(QuadCullerTest, verifyCullChildLinesUpTopLeft)
     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)
@@ -158,9 +158,9 @@ TEST_F(QuadCullerTest, verifyCullWhenChildOpacityNotOne)
     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)
@@ -175,9 +175,9 @@ TEST_F(QuadCullerTest, verifyCullWhenChildOpaqueFlagFalse)
     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)
@@ -210,9 +210,9 @@ TEST_F(QuadCullerTest, verifyCullCenterTileOnly)
     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)
@@ -238,9 +238,9 @@ TEST_F(QuadCullerTest, verifyCullCenterTileNonIntegralSize1)
     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)
@@ -266,9 +266,9 @@ TEST_F(QuadCullerTest, verifyCullCenterTileNonIntegralSize2)
     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)
@@ -285,9 +285,9 @@ TEST_F(QuadCullerTest, verifyCullChildLinesUpBottomRight)
     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)
@@ -305,9 +305,9 @@ TEST_F(QuadCullerTest, verifyCullSubRegion)
     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)
@@ -325,9 +325,9 @@ TEST_F(QuadCullerTest, verifyCullSubRegion2)
     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)
@@ -345,9 +345,9 @@ TEST_F(QuadCullerTest, verifyCullSubRegionCheckOvercull)
     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)
@@ -365,9 +365,9 @@ TEST_F(QuadCullerTest, verifyNonAxisAlignedQuadsDontOcclude)
     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.
@@ -391,9 +391,9 @@ TEST_F(QuadCullerTest, verifyNonAxisAlignedQuadsSafelyCulled)
     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)
@@ -408,9 +408,9 @@ TEST_F(QuadCullerTest, verifyCullOutsideScissorOverTile)
     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)
@@ -425,9 +425,9 @@ TEST_F(QuadCullerTest, verifyCullOutsideScissorOverCulledTile)
     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)
@@ -442,9 +442,9 @@ TEST_F(QuadCullerTest, verifyCullOutsideScissorOverPartialTiles)
     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)
@@ -459,9 +459,9 @@ TEST_F(QuadCullerTest, verifyCullOutsideScissorOverNoTiles)
     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)
@@ -476,9 +476,9 @@ TEST_F(QuadCullerTest, verifyWithoutMetrics)
     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
diff --git a/cc/tiled_layer.cc b/cc/tiled_layer.cc
index d07bb03..cfa0c88 100644
--- a/cc/tiled_layer.cc
+++ b/cc/tiled_layer.cc
@@ -323,7 +323,7 @@ bool TiledLayer::updateTiles(int left, int top, int right, int bottom, ResourceU
     gfx::Rect paintRect = markTilesForUpdate(left, top, right, bottom, ignoreOcclusions);
 
     if (occlusion)
-        occlusion->OverdrawMetrics().didPaint(paintRect);
+        occlusion->OverdrawMetrics().DidPaint(paintRect);
 
     if (paintRect.IsEmpty())
         return true;
@@ -364,7 +364,7 @@ void TiledLayer::markOcclusionsAndRequestTextures(int left, int top, int right,
     if (!succeeded)
         return;
     if (occlusion)
-        occlusion->OverdrawMetrics().didCullTilesForUpload(occludedTileCount);
+        occlusion->OverdrawMetrics().DidCullTilesForUpload(occludedTileCount);
 }
 
 bool TiledLayer::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions)
@@ -498,7 +498,7 @@ void TiledLayer::updateTileTextures(const gfx::Rect& paintRect, int left, int to
 
             tile->updaterResource()->update(queue, sourceRect, destOffset, tile->partialUpdate, stats);
             if (occlusion)
-                occlusion->OverdrawMetrics().didUpload(gfx::Transform(), sourceRect, tile->opaqueRect());
+                occlusion->OverdrawMetrics().DidUpload(gfx::Transform(), sourceRect, tile->opaqueRect());
 
         }
     }
diff --git a/cc/tiled_layer_unittest.cc b/cc/tiled_layer_unittest.cc
index 1e02385..053ebaf 100644
--- a/cc/tiled_layer_unittest.cc
+++ b/cc/tiled_layer_unittest.cc
@@ -230,9 +230,9 @@ TEST_F(TiledLayerTest, pushOccludedDirtyTiles)
     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));
@@ -245,9 +245,9 @@ TEST_F(TiledLayerTest, pushOccludedDirtyTiles)
     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));
@@ -467,7 +467,7 @@ TEST_F(TiledLayerTest, pushIdlePaintedOccludedTiles)
 
     // 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)
@@ -1030,9 +1030,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusion)
     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);
@@ -1043,9 +1043,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusion)
     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);
@@ -1056,9 +1056,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusion)
     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)
@@ -1084,9 +1084,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
     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();
 
@@ -1100,9 +1100,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
     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();
 
@@ -1116,9 +1116,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
     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());
 
 }
 
@@ -1146,9 +1146,9 @@ TEST_F(TiledLayerTest, tilesNotPaintedWithoutInvalidation)
         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);
@@ -1158,9 +1158,9 @@ TEST_F(TiledLayerTest, tilesNotPaintedWithoutInvalidation)
     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)
@@ -1190,9 +1190,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndTransforms)
     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)
@@ -1229,9 +1229,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndScaling)
     // 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();
 
@@ -1247,9 +1247,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndScaling)
     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();
 
@@ -1270,9 +1270,9 @@ TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndScaling)
     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)
@@ -1304,10 +1304,10 @@ TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
     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);
@@ -1320,10 +1320,10 @@ TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
     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());
@@ -1334,10 +1334,10 @@ TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
     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.
@@ -1350,10 +1350,10 @@ TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
     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.
@@ -1366,13 +1366,13 @@ TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
     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;
@@ -1398,10 +1398,10 @@ TEST_F(TiledLayerTest, pixelsPaintedMetrics)
     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.
@@ -1416,11 +1416,11 @@ TEST_F(TiledLayerTest, pixelsPaintedMetrics)
     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)