Revert 189428 "cc: Chromify rendering_stats"

The naming change broke the scrolling benchmark or the perf waterfall.

http://build.chromium.org/p/chromium.perf/builders/Linux%2520Perf%2520%25281%2529/builds/21581/steps/scrolling_benchmark/logs/stdio

this enumerator is exposed API to JS extensions like the gpu benchmarking
extension, so this breaks benchmarking. We'll have to figure out how to
stage this with changes to the gpu benchmarking harness.

> cc: Chromify rendering_stats
> 
> 
> BUG=
> 
> TBR=jamesr@chromium.org
> 
> Review URL: https://chromiumcodereview.appspot.com/12780025

TBR=alexst@chromium.org
Review URL: https://codereview.chromium.org/12496017

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

11 files changed, 136 insertions, 139 deletions

diff --git a/cc/debug/rendering_stats.cc b/cc/debug/rendering_stats.cc
index d0292c4..28e7089 100644
--- a/cc/debug/rendering_stats.cc
+++ b/cc/debug/rendering_stats.cc
@@ -7,74 +7,72 @@
 namespace cc {
 
 RenderingStats::RenderingStats()
-    : animation_frame_count(0),
-      screen_frame_count(0),
-      dropped_frame_count(0),
-      total_commit_count(0),
-      total_pixels_painted(0),
-      total_pixels_rasterized(0),
-      num_impl_thread_scrolls(0),
-      num_main_thread_scrolls(0),
-      num_layers_drawn(0),
-      num_missing_tiles(0),
-      total_deferred_image_decode_count(0),
-      total_deferred_image_cache_hit_count(0),
-      total_image_gathering_count(0) {}
+    : numAnimationFrames(0),
+      numFramesSentToScreen(0),
+      droppedFrameCount(0),
+      totalCommitCount(0),
+      totalPixelsPainted(0),
+      totalPixelsRasterized(0),
+      numImplThreadScrolls(0),
+      numMainThreadScrolls(0),
+      numLayersDrawn(0),
+      numMissingTiles(0),
+      totalDeferredImageDecodeCount(0),
+      totalDeferredImageCacheHitCount(0),
+      totalImageGatheringCount(0) {
+}
 
 void RenderingStats::EnumerateFields(Enumerator* enumerator) const {
-  enumerator->AddInt64("animation_frame_count", animation_frame_count);
-  enumerator->AddInt64("screen_frame_count", screen_frame_count);
-  enumerator->AddInt64("dropped_frame_count", dropped_frame_count);
-  enumerator->AddDouble("total_paint_timeInSeconds",
-                        total_paint_time.InSecondsF());
-  enumerator->AddDouble("total_rasterize_timeInSeconds",
-                        total_rasterize_time.InSecondsF());
-  enumerator->AddDouble(
-      "total_rasterize_time_for_now_bins_on_pending_tree",
-      total_rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
-  enumerator->AddDouble("total_commit_timeInSeconds",
-                        total_commit_time.InSecondsF());
-  enumerator->AddInt64("total_commit_count", total_commit_count);
-  enumerator->AddInt64("total_pixels_painted", total_pixels_painted);
-  enumerator->AddInt64("total_pixels_rasterized", total_pixels_rasterized);
-  enumerator->AddInt64("num_impl_thread_scrolls", num_impl_thread_scrolls);
-  enumerator->AddInt64("num_main_thread_scrolls", num_main_thread_scrolls);
-  enumerator->AddInt64("num_layers_drawn", num_layers_drawn);
-  enumerator->AddInt64("num_missing_tiles", num_missing_tiles);
-  enumerator->AddInt64("total_deferred_image_decode_count",
-                       total_deferred_image_decode_count);
-  enumerator->AddInt64("total_deferred_image_cache_hit_count",
-                       total_deferred_image_cache_hit_count);
-  enumerator->AddInt64("total_image_gathering_count",
-                       total_image_gathering_count);
-  enumerator->AddDouble("total_deferred_image_decode_timeInSeconds",
-                        total_deferred_image_decode_time.InSecondsF());
-  enumerator->AddDouble("total_image_gathering_timeInSeconds",
-                        total_image_gathering_time.InSecondsF());
+    enumerator->AddInt64("numAnimationFrames", numAnimationFrames);
+    enumerator->AddInt64("numFramesSentToScreen", numFramesSentToScreen);
+    enumerator->AddInt64("droppedFrameCount", droppedFrameCount);
+    enumerator->AddDouble("totalPaintTimeInSeconds",
+                          totalPaintTime.InSecondsF());
+    enumerator->AddDouble("totalRasterizeTimeInSeconds",
+                          totalRasterizeTime.InSecondsF());
+    enumerator->AddDouble("totalRasterizeTimeForNowBinsOnPendingTree",
+        totalRasterizeTimeForNowBinsOnPendingTree.InSecondsF());
+    enumerator->AddDouble("totalCommitTimeInSeconds",
+                          totalCommitTime.InSecondsF());
+    enumerator->AddInt64("totalCommitCount", totalCommitCount);
+    enumerator->AddInt64("totalPixelsPainted", totalPixelsPainted);
+    enumerator->AddInt64("totalPixelsRasterized", totalPixelsRasterized);
+    enumerator->AddInt64("numImplThreadScrolls", numImplThreadScrolls);
+    enumerator->AddInt64("numMainThreadScrolls", numMainThreadScrolls);
+    enumerator->AddInt64("numLayersDrawn", numLayersDrawn);
+    enumerator->AddInt64("numMissingTiles", numMissingTiles);
+    enumerator->AddInt64("totalDeferredImageDecodeCount",
+                         totalDeferredImageDecodeCount);
+    enumerator->AddInt64("totalDeferredImageCacheHitCount",
+                         totalDeferredImageCacheHitCount);
+    enumerator->AddInt64("totalImageGatheringCount", totalImageGatheringCount);
+    enumerator->AddDouble("totalDeferredImageDecodeTimeInSeconds",
+                          totalDeferredImageDecodeTime.InSecondsF());
+    enumerator->AddDouble("totalImageGatheringTimeInSeconds",
+                          totalImageGatheringTime.InSecondsF());
 }
 
 void RenderingStats::Add(const RenderingStats& other) {
-  animation_frame_count += other.animation_frame_count;
-  screen_frame_count += other.screen_frame_count;
-  dropped_frame_count += other.dropped_frame_count;
-  total_paint_time += other.total_paint_time;
-  total_rasterize_time += other.total_rasterize_time;
-  total_rasterize_time_for_now_bins_on_pending_tree +=
-      other.total_rasterize_time_for_now_bins_on_pending_tree;
-  total_commit_time += other.total_commit_time;
-  total_commit_count += other.total_commit_count;
-  total_pixels_painted += other.total_pixels_painted;
-  total_pixels_rasterized += other.total_pixels_rasterized;
-  num_impl_thread_scrolls += other.num_impl_thread_scrolls;
-  num_main_thread_scrolls += other.num_main_thread_scrolls;
-  num_layers_drawn += other.num_layers_drawn;
-  num_missing_tiles += other.num_missing_tiles;
-  total_deferred_image_decode_count += other.total_deferred_image_decode_count;
-  total_deferred_image_cache_hit_count +=
-      other.total_deferred_image_cache_hit_count;
-  total_image_gathering_count += other.total_image_gathering_count;
-  total_deferred_image_decode_time += other.total_deferred_image_decode_time;
-  total_image_gathering_time += other.total_image_gathering_time;
+  numAnimationFrames += other.numAnimationFrames;
+  numFramesSentToScreen += other.numFramesSentToScreen;
+  droppedFrameCount += other.droppedFrameCount;
+  totalPaintTime += other.totalPaintTime;
+  totalRasterizeTime += other.totalRasterizeTime;
+  totalRasterizeTimeForNowBinsOnPendingTree +=
+      other.totalRasterizeTimeForNowBinsOnPendingTree;
+  totalCommitTime += other.totalCommitTime;
+  totalCommitCount += other.totalCommitCount;
+  totalPixelsPainted += other.totalPixelsPainted;
+  totalPixelsRasterized += other.totalPixelsRasterized;
+  numImplThreadScrolls += other.numImplThreadScrolls;
+  numMainThreadScrolls += other.numMainThreadScrolls;
+  numLayersDrawn += other.numLayersDrawn;
+  numMissingTiles += other.numMissingTiles;
+  totalDeferredImageDecodeCount += other.totalDeferredImageDecodeCount;
+  totalDeferredImageCacheHitCount += other.totalDeferredImageCacheHitCount;
+  totalImageGatheringCount += other.totalImageGatheringCount;
+  totalDeferredImageDecodeTime += other.totalDeferredImageDecodeTime;
+  totalImageGatheringTime += other.totalImageGatheringTime;
 }
 
 }  // namespace cc
diff --git a/cc/debug/rendering_stats.h b/cc/debug/rendering_stats.h
index 33ea2c6..799bd88 100644
--- a/cc/debug/rendering_stats.h
+++ b/cc/debug/rendering_stats.h
@@ -12,51 +12,52 @@
 namespace cc {
 
 struct CC_EXPORT RenderingStats {
-  int64 animation_frame_count;
-  int64 screen_frame_count;
-  int64 dropped_frame_count;
-  base::TimeDelta total_paint_time;
-  base::TimeDelta total_rasterize_time;
-  base::TimeDelta total_rasterize_time_for_now_bins_on_pending_tree;
-  base::TimeDelta total_commit_time;
-  int64 total_commit_count;
-  int64 total_pixels_painted;
-  int64 total_pixels_rasterized;
-  int64 num_impl_thread_scrolls;
-  int64 num_main_thread_scrolls;
-  int64 num_layers_drawn;
-  int64 num_missing_tiles;
-  int64 total_deferred_image_decode_count;
-  int64 total_deferred_image_cache_hit_count;
-  int64 total_image_gathering_count;
-  base::TimeDelta total_deferred_image_decode_time;
-  base::TimeDelta total_image_gathering_time;
-  // Note: when adding new members, please remember to update EnumerateFields
-  // and Add in rendering_stats.cc.
+    // FIXME: Rename these to animationFrameCount and screenFrameCount, crbug.com/138641.
+    int64 numAnimationFrames;
+    int64 numFramesSentToScreen;
+    int64 droppedFrameCount;
+    base::TimeDelta totalPaintTime;
+    base::TimeDelta totalRasterizeTime;
+    base::TimeDelta totalRasterizeTimeForNowBinsOnPendingTree;
+    base::TimeDelta totalCommitTime;
+    int64 totalCommitCount;
+    int64 totalPixelsPainted;
+    int64 totalPixelsRasterized;
+    int64 numImplThreadScrolls;
+    int64 numMainThreadScrolls;
+    int64 numLayersDrawn;
+    int64 numMissingTiles;
+    int64 totalDeferredImageDecodeCount;
+    int64 totalDeferredImageCacheHitCount;
+    int64 totalImageGatheringCount;
+    base::TimeDelta totalDeferredImageDecodeTime;
+    base::TimeDelta totalImageGatheringTime;
+    // Note: when adding new members, please remember to update EnumerateFields
+    // and Add in rendering_stats.cc.
 
-  RenderingStats();
+    RenderingStats();
 
-  // In conjunction with enumerateFields, this allows the embedder to
-  // enumerate the values in this structure without
-  // having to embed references to its specific member variables. This
-  // simplifies the addition of new fields to this type.
-  class Enumerator {
-   public:
-    virtual void AddInt64(const char* name, int64 value) = 0;
-    virtual void AddDouble(const char* name, double value) = 0;
-    virtual void AddInt(const char* name, int value) = 0;
-    virtual void AddTimeDeltaInSecondsF(const char* name,
-                                        const base::TimeDelta& value) = 0;
+    // In conjunction with enumerateFields, this allows the embedder to
+    // enumerate the values in this structure without
+    // having to embed references to its specific member variables. This
+    // simplifies the addition of new fields to this type.
+    class Enumerator {
+    public:
+        virtual void AddInt64(const char* name, int64 value) = 0;
+        virtual void AddDouble(const char* name, double value) = 0;
+        virtual void AddInt(const char* name, int value) = 0;
+        virtual void AddTimeDeltaInSecondsF(const char* name,
+                                            const base::TimeDelta& value) = 0;
 
-   protected:
-    virtual ~Enumerator() {}
-  };
+    protected:
+        virtual ~Enumerator() { }
+    };
 
-  // Outputs the fields in this structure to the provided enumerator.
-  void EnumerateFields(Enumerator* enumerator) const;
+    // Outputs the fields in this structure to the provided enumerator.
+    void EnumerateFields(Enumerator* enumerator) const;
 
-  // Add fields of |other| to the fields in this structure.
-  void Add(const RenderingStats& other);
+    // Add fields of |other| to the fields in this structure.
+    void Add(const RenderingStats& other);
 };
 
 }  // namespace cc
diff --git a/cc/resources/bitmap_content_layer_updater.cc b/cc/resources/bitmap_content_layer_updater.cc
index fa483b7..8a65e9e 100644
--- a/cc/resources/bitmap_content_layer_updater.cc
+++ b/cc/resources/bitmap_content_layer_updater.cc
@@ -60,7 +60,7 @@ void BitmapContentLayerUpdater::PrepareToUpdate(
   }
 
   if (stats) {
-    stats->total_pixels_rasterized +=
+    stats->totalPixelsRasterized +=
         content_rect.width() * content_rect.height();
   }
 
diff --git a/cc/resources/bitmap_skpicture_content_layer_updater.cc b/cc/resources/bitmap_skpicture_content_layer_updater.cc
index a75c89a..e2fdc04 100644
--- a/cc/resources/bitmap_skpicture_content_layer_updater.cc
+++ b/cc/resources/bitmap_skpicture_content_layer_updater.cc
@@ -36,7 +36,7 @@ void BitmapSkPictureContentLayerUpdater::Resource::Update(
     paint_begin_time = base::TimeTicks::Now();
   updater_->PaintContentsRect(&canvas, source_rect, stats);
   if (stats)
-    stats->total_paint_time += base::TimeTicks::Now() - paint_begin_time;
+    stats->totalPaintTime += base::TimeTicks::Now() - paint_begin_time;
 
   ResourceUpdate upload = ResourceUpdate::Create(
       texture(), &bitmap_, source_rect, source_rect, dest_offset);
@@ -77,8 +77,8 @@ void BitmapSkPictureContentLayerUpdater::PaintContentsRect(
     rasterize_begin_time = base::TimeTicks::Now();
   DrawPicture(canvas);
   if (stats) {
-    stats->total_rasterize_time += base::TimeTicks::Now() - rasterize_begin_time;
-    stats->total_pixels_rasterized += source_rect.width() * source_rect.height();
+    stats->totalRasterizeTime += base::TimeTicks::Now() - rasterize_begin_time;
+    stats->totalPixelsRasterized += source_rect.width() * source_rect.height();
   }
 }
 
diff --git a/cc/resources/content_layer_updater.cc b/cc/resources/content_layer_updater.cc
index 4865a49..b4eb1d2 100644
--- a/cc/resources/content_layer_updater.cc
+++ b/cc/resources/content_layer_updater.cc
@@ -58,8 +58,8 @@ void ContentLayerUpdater::PaintContents(SkCanvas* canvas,
     paint_begin_time = base::TimeTicks::Now();
   painter_->Paint(canvas, layer_rect, &opaque_layer_rect);
   if (stats) {
-    stats->total_paint_time += base::TimeTicks::Now() - paint_begin_time;
-    stats->total_pixels_painted += content_rect.width() * content_rect.height();
+    stats->totalPaintTime += base::TimeTicks::Now() - paint_begin_time;
+    stats->totalPixelsPainted += content_rect.width() * content_rect.height();
   }
   canvas->restore();
 
diff --git a/cc/resources/picture.cc b/cc/resources/picture.cc
index ccab893..a343237 100644
--- a/cc/resources/picture.cc
+++ b/cc/resources/picture.cc
@@ -102,8 +102,8 @@ void Picture::Record(ContentLayerClient* painter,
     begin_paint_time = base::TimeTicks::Now();
   painter->PaintContents(canvas, layer_rect_, &opaque_layer_rect);
   if (stats) {
-    stats->total_paint_time += base::TimeTicks::Now() - begin_paint_time;
-    stats->total_pixels_painted +=
+    stats->totalPaintTime += base::TimeTicks::Now() - begin_paint_time;
+    stats->totalPixelsPainted +=
         layer_rect_.width() * layer_rect_.height();
   }
 
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 88b7c84..61e112b 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -505,12 +505,11 @@ void TileManager::SetRecordRenderingStats(bool record_rendering_stats) {
 void TileManager::GetRenderingStats(RenderingStats* stats) {
   CHECK(record_rendering_stats_);
   raster_worker_pool_->GetRenderingStats(stats);
-  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;
-  stats->total_image_gathering_time =
-      rendering_stats_.total_image_gathering_time;
+  stats->totalDeferredImageCacheHitCount =
+      rendering_stats_.totalDeferredImageCacheHitCount;
+  stats->totalImageGatheringCount = rendering_stats_.totalImageGatheringCount;
+  stats->totalImageGatheringTime =
+      rendering_stats_.totalImageGatheringTime;
 }
 
 bool TileManager::HasPendingWorkScheduled(WhichTree tree) const {
@@ -748,8 +747,8 @@ void TileManager::GatherPixelRefsForTile(Tile* tile) {
         managed_tile_state.pending_pixel_refs);
     managed_tile_state.need_to_gather_pixel_refs = false;
     if (record_rendering_stats_) {
-      rendering_stats_.total_image_gathering_count++;
-      rendering_stats_.total_image_gathering_time +=
+      rendering_stats_.totalImageGatheringCount++;
+      rendering_stats_.totalImageGatheringTime +=
           base::TimeTicks::HighResNow() - gather_begin_time;
     }
   }
@@ -768,7 +767,7 @@ void TileManager::DispatchImageDecodeTasksForTile(Tile* tile) {
     }
     // TODO(qinmin): passing correct image size to PrepareToDecode().
     if ((*it)->PrepareToDecode(skia::LazyPixelRef::PrepareParams())) {
-      rendering_stats_.total_deferred_image_cache_hit_count++;
+      rendering_stats_.totalDeferredImageCacheHitCount++;
       pending_pixel_refs.erase(it++);
     } else {
       if (pending_tasks_ >= max_pending_tasks_)
@@ -1005,13 +1004,13 @@ void TileManager::RunRasterTask(uint8* buffer,
                        &total_pixels_rasterized);
 
   if (stats) {
-    stats->total_pixels_rasterized += total_pixels_rasterized;
+    stats->totalPixelsRasterized += total_pixels_rasterized;
 
     base::TimeTicks end_time = base::TimeTicks::HighResNow();
     base::TimeDelta duration = end_time - begin_time;
-    stats->total_rasterize_time += duration;
+    stats->totalRasterizeTime += duration;
     if (metadata.is_tile_in_pending_tree_now_bin)
-      stats->total_rasterize_time_for_now_bins_on_pending_tree += duration;
+      stats->totalRasterizeTimeForNowBinsOnPendingTree += duration;
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
                                 duration.InMilliseconds(),
@@ -1112,8 +1111,8 @@ void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
     decode_begin_time = base::TimeTicks::HighResNow();
   pixel_ref->Decode();
   if (stats) {
-    stats->total_deferred_image_decode_count++;
-    stats->total_deferred_image_decode_time +=
+    stats->totalDeferredImageDecodeCount++;
+    stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::HighResNow() - decode_begin_time;
   }
 }
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 4d6727f..769bac8 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -230,7 +230,7 @@ void LayerTreeHost::UpdateAnimations(base::TimeTicks frame_begin_time) {
   AnimateLayers(frame_begin_time);
   animating_ = false;
 
-  rendering_stats_.animation_frame_count++;
+  rendering_stats_.numAnimationFrames++;
 }
 
 void LayerTreeHost::DidStopFlinging() {
@@ -346,8 +346,7 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   }
 
   if (debug_state_.continuous_painting)
-    host_impl->SavePaintTime(rendering_stats_.total_paint_time,
-                             commit_number());
+    host_impl->SavePaintTime(rendering_stats_.totalPaintTime, commit_number());
 
   commit_number_++;
 }
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 443e3d7..216f6ce 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1177,7 +1177,7 @@ void LayerTreeHostImpl::ActivatePendingTree() {
     RenderingStats stats;
     tile_manager_->GetRenderingStats(&stats);
     paint_time_counter_->SaveRasterizeTime(
-        stats.total_rasterize_time_for_now_bins_on_pending_tree,
+        stats.totalRasterizeTimeForNowBinsOnPendingTree,
         active_tree_->source_frame_number());
   }
 }
@@ -1796,12 +1796,12 @@ int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
 }
 
 void LayerTreeHostImpl::CollectRenderingStats(RenderingStats* stats) const {
-  stats->screen_frame_count = fps_counter_->current_frame_number();
-  stats->dropped_frame_count = fps_counter_->dropped_frame_count();
-  stats->num_impl_thread_scrolls = num_impl_thread_scrolls_;
-  stats->num_main_thread_scrolls = num_main_thread_scrolls_;
-  stats->num_layers_drawn = cumulative_num_layers_drawn_;
-  stats->num_missing_tiles = cumulative_num_missing_tiles_;
+  stats->numFramesSentToScreen = fps_counter_->current_frame_number();
+  stats->droppedFrameCount = fps_counter_->dropped_frame_count();
+  stats->numImplThreadScrolls = num_impl_thread_scrolls_;
+  stats->numMainThreadScrolls = num_main_thread_scrolls_;
+  stats->numLayersDrawn = cumulative_num_layers_drawn_;
+  stats->numMissingTiles = cumulative_num_missing_tiles_;
 
   if (tile_manager_)
     tile_manager_->GetRenderingStats(stats);
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index c615d2d..8dbf352 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -172,8 +172,8 @@ bool SingleThreadProxy::RecreateOutputSurface() {
 }
 
 void SingleThreadProxy::CollectRenderingStats(RenderingStats* stats) {
-  stats->total_commit_time = total_commit_time_;
-  stats->total_commit_count = total_commit_count_;
+  stats->totalCommitTime = total_commit_time_;
+  stats->totalCommitCount = total_commit_count_;
   layer_tree_host_impl_->CollectRenderingStats(stats);
 }
 
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 22ee71c6..0974592 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -288,8 +288,8 @@ void ThreadProxy::CollectRenderingStats(RenderingStats* stats) {
                  impl_thread_weak_ptr_,
                  &completion,
                  stats));
-  stats->total_commit_time = total_commit_time_;
-  stats->total_commit_count = total_commit_count_;
+  stats->totalCommitTime = total_commit_time_;
+  stats->totalCommitCount = total_commit_count_;
 
   completion.Wait();
 }