cc: Chromify rendering_stats

content/renderer/render_widget.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 873 matching lines @@
 
     SkAutoCanvasRestore auto_restore(canvas, true);
     canvas->scale(device_scale_factor_, device_scale_factor_);
     optimized_instance->Paint(webkit_glue::ToWebCanvas(canvas),
                               optimized_copy_location, rect);
     canvas->restore();
     if (kEnableGpuBenchmarking) {
       base::TimeDelta paint_time =
           base::TimeTicks::HighResNow() - paint_begin_ticks;
       if (!is_accelerated_compositing_active_)
-        software_stats_.totalPaintTime += paint_time;
+        software_stats_.total_paint_time += paint_time;
     }
   } else {
     // Normal painting case.
     base::TimeTicks paint_begin_ticks;
     if (kEnableGpuBenchmarking)
       paint_begin_ticks = base::TimeTicks::HighResNow();
 
     webwidget_->paint(webkit_glue::ToWebCanvas(canvas), rect);
 
     if (kEnableGpuBenchmarking) {
       base::TimeDelta paint_time =
           base::TimeTicks::HighResNow() - paint_begin_ticks;
       if (!is_accelerated_compositing_active_)
-        software_stats_.totalPaintTime += paint_time;
+        software_stats_.total_paint_time += paint_time;
     }
 
     // Flush to underlying bitmap.  TODO(darin): is this needed?
     skia::GetTopDevice(*canvas)->accessBitmap(false);
   }
 
   PaintDebugBorder(rect, canvas);
   canvas->restore();
 
   if (kEnableGpuBenchmarking) {
     int64 num_pixels_processed = rect.width() * rect.height();
-    software_stats_.totalPixelsPainted += num_pixels_processed;
-    software_stats_.totalPixelsRasterized += num_pixels_processed;
+    software_stats_.total_pixels_painted += num_pixels_processed;
+    software_stats_.total_pixels_rasterized += num_pixels_processed;
   }
 }
 
 void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
                                     skia::PlatformCanvas* canvas) {
   static bool kPaintBorder =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
   if (!kPaintBorder)
     return;
 
@@ skipping 183 matching lines @@
     }
 
     // Calculate filtered time per frame:
     float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
     filtered_time_per_frame_ =
         0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
   }
   last_do_deferred_update_time_ = frame_begin_ticks;
 
   if (!is_accelerated_compositing_active_) {
-    software_stats_.numAnimationFrames++;
-    software_stats_.numFramesSentToScreen++;
+    software_stats_.num_animation_frames++;
+    software_stats_.num_frames_sent_to_screen++;
   }
 
   // OK, save the pending update to a local since painting may cause more
   // invalidation.  Some WebCore rendering objects only layout when painted.
   PaintAggregator::PendingUpdate update;
   paint_aggregator_.PopPendingUpdate(&update);
 
   gfx::Rect scroll_damage = update.GetScrollDamage();
   gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
 
@@ skipping 1046 matching lines @@
       break;
     }
   }
 }
 
 void RenderWidget::GetRenderingStats(
     WebKit::WebRenderingStatsImpl& stats) const {
   if (compositor_)
     compositor_->GetRenderingStats(&stats.rendering_stats);
 
-  stats.rendering_stats.numAnimationFrames +=
-      software_stats_.numAnimationFrames;
-  stats.rendering_stats.numFramesSentToScreen +=
-      software_stats_.numFramesSentToScreen;
-  stats.rendering_stats.totalPaintTime +=
-      software_stats_.totalPaintTime;
-  stats.rendering_stats.totalPixelsPainted +=
-      software_stats_.totalPixelsPainted;
-  stats.rendering_stats.totalRasterizeTime +=
-      software_stats_.totalRasterizeTime;
-  stats.rendering_stats.totalPixelsRasterized +=
-      software_stats_.totalPixelsRasterized;
+  stats.rendering_stats.num_animation_frames +=
+      software_stats_.num_animation_frames;
+  stats.rendering_stats.num_frames_sent_to_screen +=
+      software_stats_.num_frames_sent_to_screen;
+  stats.rendering_stats.total_paint_time +=
+      software_stats_.total_paint_time;
+  stats.rendering_stats.total_pixels_painted +=
+      software_stats_.total_pixels_painted;
+  stats.rendering_stats.total_rasterize_time +=
+      software_stats_.total_rasterize_time;
+  stats.rendering_stats.total_pixels_rasterized +=
+      software_stats_.total_pixels_rasterized;
 }
 
 bool RenderWidget::GetGpuRenderingStats(GpuRenderingStats* stats) const {
   GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
   if (!gpu_channel)
     return false;
 
   return gpu_channel->CollectRenderingStatsForSurface(surface_id(), stats);
 }
 
@@ skipping 50 matching lines @@
     if (!context->Initialize(
             attributes,
             false /* bind generates resources */,
             CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
       return NULL;
     return context.release();
   }
 }
 
 }  // namespace content