cc: Chromify rendering_stats

cc/resources/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 487 matching lines @@
   if (record_rendering_stats_ == record_rendering_stats)
     return;
 
   record_rendering_stats_ = record_rendering_stats;
   raster_worker_pool_->SetRecordRenderingStats(record_rendering_stats);
 }
 
 void TileManager::GetRenderingStats(RenderingStats* stats) {
   CHECK(record_rendering_stats_);
   raster_worker_pool_->GetRenderingStats(stats);
-  stats->totalDeferredImageCacheHitCount =
-      rendering_stats_.totalDeferredImageCacheHitCount;
-  stats->totalImageGatheringCount = rendering_stats_.totalImageGatheringCount;
-  stats->totalImageGatheringTime =
-      rendering_stats_.totalImageGatheringTime;
+  stats->total_deferred_image_cache_hit_count =
+      rendering_stats_.total_deferred_image_cache_hit_count;
+  stats->total_image_gathering_count = rendering_stats_.total_image_gathering_count;

[danakj, 2013/03/20 19:00:43]

80 col

+  stats->total_image_gathering_time =
+      rendering_stats_.total_image_gathering_time;
 }
 
 bool TileManager::HasPendingWorkScheduled(WhichTree tree) const {
   // Always true when ManageTiles() call is pending.
   if (manage_tiles_pending_)
     return true;
 
   for (int i = 0; i < NUM_STATES; ++i) {
     switch (i) {
       case WAITING_FOR_RASTER_STATE:
@@ skipping 217 matching lines @@
   if (managed_tile_state.need_to_gather_pixel_refs) {
     base::TimeTicks gather_begin_time;
     if (record_rendering_stats_)
       gather_begin_time = base::TimeTicks::HighResNow();
     tile->picture_pile()->GatherPixelRefs(
         tile->content_rect_,
         tile->contents_scale_,
         managed_tile_state.pending_pixel_refs);
     managed_tile_state.need_to_gather_pixel_refs = false;
     if (record_rendering_stats_) {
-      rendering_stats_.totalImageGatheringCount++;
-      rendering_stats_.totalImageGatheringTime +=
+      rendering_stats_.total_image_gathering_count++;
+      rendering_stats_.total_image_gathering_time +=
           base::TimeTicks::HighResNow() - gather_begin_time;
     }
   }
 }
 
 void TileManager::DispatchImageDecodeTasksForTile(Tile* tile) {
   GatherPixelRefsForTile(tile);
   std::list<skia::LazyPixelRef*>& pending_pixel_refs =
       tile->managed_state().pending_pixel_refs;
   std::list<skia::LazyPixelRef*>::iterator it = pending_pixel_refs.begin();
   while (it != pending_pixel_refs.end()) {
     if (pending_decode_tasks_.end() != pending_decode_tasks_.find(
         (*it)->getGenerationID())) {
       ++it;
       continue;
     }
     // TODO(qinmin): passing correct image size to PrepareToDecode().
     if ((*it)->PrepareToDecode(skia::LazyPixelRef::PrepareParams())) {
-      rendering_stats_.totalDeferredImageCacheHitCount++;
+      rendering_stats_.total_deferred_image_cache_hit_count++;
       pending_pixel_refs.erase(it++);
     } else {
       if (pending_tasks_ >= max_pending_tasks_)
         return;
       DispatchOneImageDecodeTask(tile, *it);
       ++it;
     }
   }
 }
 
@@ skipping 216 matching lines @@
 
   base::TimeTicks begin_time;
   if (stats)
     begin_time = base::TimeTicks::HighResNow();
 
   int64 total_pixels_rasterized = 0;
   picture_pile->Raster(&canvas, rect, contents_scale,
                        &total_pixels_rasterized);
 
   if (stats) {
-    stats->totalPixelsRasterized += total_pixels_rasterized;
+    stats->total_pixels_rasterized += total_pixels_rasterized;
 
     base::TimeTicks end_time = base::TimeTicks::HighResNow();
     base::TimeDelta duration = end_time - begin_time;
-    stats->totalRasterizeTime += duration;
+    stats->total_rasterize_time += duration;
     if (metadata.is_tile_in_pending_tree_now_bin)
-      stats->totalRasterizeTimeForNowBinsOnPendingTree += duration;
+      stats->total_rasterize_time_for_now_bins_on_pending_tree += duration;
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
                                 duration.InMilliseconds(),
                                 0,
                                 10,
                                 10);
 
     if (metadata.prediction_benchmarking) {
       PicturePileImpl::Analysis analysis;
       picture_pile->AnalyzeInRect(rect, contents_scale, &analysis);
@@ skipping 80 matching lines @@
 
 // static
 void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks decode_begin_time;
   if (stats)
     decode_begin_time = base::TimeTicks::HighResNow();
   pixel_ref->Decode();
   if (stats) {
-    stats->totalDeferredImageDecodeCount++;
-    stats->totalDeferredImageDecodeTime +=
+    stats->total_deferred_image_decode_count++;
+    stats->total_deferred_image_decode_time +=
         base::TimeTicks::HighResNow() - decode_begin_time;
   }
 }
 
 }  // namespace cc