Revert 217824 "cc: RenderingStats overhaul"

Speculative. May have broken smoothness_measurement on Mac 10.7.

> cc: RenderingStats overhaul
> - Split RenderingStats into MainThreadRenderingStats and
>   ImplThreadRenderingStats
> - Support accumulated stats and per-frame stats in RenderingStatsInstrumentation
> - Dump MainThreadRenderingStats into trace event from 
>   ThreadProxy::BeginFrameOnMainThread
> - Dump ImplThreadRenderingStats into trace event from
>   LayerTreeHostImpl::DrawLayers
> - Made naming of RenderingStats members consistent
> 
> R=nduca@chromium.org,jamesr@chromium.org
> BUG=266101,264308
> 
> Review URL: https://chromiumcodereview.appspot.com/23088002

TBR=ernstm@chromium.org

Review URL: https://codereview.chromium.org/23155003

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

4 files changed, 138 insertions, 284 deletions

diff --git a/cc/debug/rendering_stats.cc b/cc/debug/rendering_stats.cc
index e8a758c..12c5453 100644
--- a/cc/debug/rendering_stats.cc
+++ b/cc/debug/rendering_stats.cc
@@ -2,185 +2,98 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/values.h"
 #include "cc/debug/rendering_stats.h"
 
 namespace cc {
 
-MainThreadRenderingStats::MainThreadRenderingStats()
-  : animation_frame_count(0),
-    screen_frame_count(0),
-    commit_count(0),
-    painted_pixel_count(0),
-    recorded_pixel_count(0),
-    image_gathering_count(0) {}
-
-ImplThreadRenderingStats::ImplThreadRenderingStats()
-    : screen_frame_count(0),
+RenderingStats::RenderingStats()
+    : animation_frame_count(0),
+      screen_frame_count(0),
       dropped_frame_count(0),
-      rasterized_pixel_count(0),
-      impl_thread_scroll_count(0),
-      main_thread_scroll_count(0),
-      drawn_layer_count(0),
-      missing_tile_count(0),
-      deferred_image_decode_count(0),
-      deferred_image_cache_hit_count(0),
-      tile_analysis_count(0),
-      solid_color_tile_analysis_count(0) {}
+      total_commit_count(0),
+      total_pixels_painted(0),
+      total_pixels_recorded(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),
+      total_tiles_analyzed(0),
+      solid_color_tiles_analyzed(0) {}
 
-void MainThreadRenderingStats::EnumerateFields(
-    RenderingStatsEnumerator* enumerator) const {
+void RenderingStats::EnumerateFields(Enumerator* enumerator) const {
   enumerator->AddInt64("numAnimationFrames", animation_frame_count);
   enumerator->AddInt64("numFramesSentToScreen", screen_frame_count);
+  enumerator->AddInt64("droppedFrameCount", dropped_frame_count);
   enumerator->AddDouble("totalPaintTimeInSeconds",
-                        paint_time.InSecondsF());
+                        total_paint_time.InSecondsF());
   enumerator->AddDouble("totalRecordTimeInSeconds",
-                        record_time.InSecondsF());
-  enumerator->AddDouble("totalCommitTimeInSeconds",
-                        commit_time.InSecondsF());
-  enumerator->AddInt64("totalCommitCount", commit_count);
-  enumerator->AddInt64("totalPixelsPainted", painted_pixel_count);
-  enumerator->AddInt64("totalPixelsRecorded", recorded_pixel_count);
-  enumerator->AddInt64("totalImageGatheringCount",
-                       image_gathering_count);
-  enumerator->AddDouble("totalImageGatheringTimeInSeconds",
-                        image_gathering_time.InSecondsF());
-}
-
-void ImplThreadRenderingStats::EnumerateFields(
-    RenderingStatsEnumerator* enumerator) const {
-  enumerator->AddInt64("numFramesSentToScreen", screen_frame_count);
-  enumerator->AddInt64("droppedFrameCount", dropped_frame_count);
+                        total_record_time.InSecondsF());
   enumerator->AddDouble("totalRasterizeTimeInSeconds",
-                        rasterize_time.InSecondsF());
+                        total_rasterize_time.InSecondsF());
   enumerator->AddDouble(
       "totalRasterizeTimeForNowBinsOnPendingTree",
-      rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
+      total_rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
+  enumerator->AddDouble("totalCommitTimeInSeconds",
+                        total_commit_time.InSecondsF());
   enumerator->AddDouble("bestRasterizeTimeInSeconds",
                         best_rasterize_time.InSecondsF());
-  enumerator->AddInt64("totalPixelsRasterized", rasterized_pixel_count);
-  enumerator->AddInt64("numImplThreadScrolls", impl_thread_scroll_count);
-  enumerator->AddInt64("numMainThreadScrolls", main_thread_scroll_count);
-  enumerator->AddInt64("numLayersDrawn", drawn_layer_count);
-  enumerator->AddInt64("numMissingTiles", missing_tile_count);
+  enumerator->AddInt64("totalCommitCount", total_commit_count);
+  enumerator->AddInt64("totalPixelsPainted", total_pixels_painted);
+  enumerator->AddInt64("totalPixelsRecorded", total_pixels_recorded);
+  enumerator->AddInt64("totalPixelsRasterized", total_pixels_rasterized);
+  enumerator->AddInt64("numImplThreadScrolls", num_impl_thread_scrolls);
+  enumerator->AddInt64("numMainThreadScrolls", num_main_thread_scrolls);
+  enumerator->AddInt64("numLayersDrawn", num_layers_drawn);
+  enumerator->AddInt64("numMissingTiles", num_missing_tiles);
   enumerator->AddInt64("totalDeferredImageDecodeCount",
-                       deferred_image_decode_count);
-  enumerator->AddInt64("totalTilesAnalyzed", tile_analysis_count);
+                       total_deferred_image_decode_count);
+  enumerator->AddInt64("totalTilesAnalyzed", total_tiles_analyzed);
   enumerator->AddInt64("solidColorTilesAnalyzed",
-                       solid_color_tile_analysis_count);
+                       solid_color_tiles_analyzed);
   enumerator->AddInt64("totalDeferredImageCacheHitCount",
-                       deferred_image_cache_hit_count);
+                       total_deferred_image_cache_hit_count);
+  enumerator->AddInt64("totalImageGatheringCount",
+                       total_image_gathering_count);
   enumerator->AddDouble("totalDeferredImageDecodeTimeInSeconds",
-                        deferred_image_decode_time.InSecondsF());
+                        total_deferred_image_decode_time.InSecondsF());
+  enumerator->AddDouble("totalImageGatheringTimeInSeconds",
+                        total_image_gathering_time.InSecondsF());
   enumerator->AddDouble("totalTileAnalysisTimeInSeconds",
-                        tile_analysis_time.InSecondsF());
-}
-
-void RenderingStats::EnumerateFields(Enumerator* enumerator) const {
-  main_stats.EnumerateFields(enumerator);
-  impl_stats.EnumerateFields(enumerator);
-}
-
-scoped_ptr<base::debug::ConvertableToTraceFormat>
-MainThreadRenderingStats::AsTraceableData() const {
-  scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
-  record_data->SetInteger("animation_frame_count",
-                          animation_frame_count);
-  record_data->SetInteger("screen_frame_count",
-                          screen_frame_count);
-  record_data->SetDouble("paint_time",
-                         paint_time.InSecondsF());
-  record_data->SetDouble("record_time",
-                         record_time.InSecondsF());
-  record_data->SetDouble("commit_time",
-                         commit_time.InSecondsF());
-  record_data->SetInteger("commit_count",
-                          commit_count);
-  record_data->SetInteger("painted_pixel_count",
-                          painted_pixel_count);
-  record_data->SetInteger("recorded_pixel_count",
-                          recorded_pixel_count);
-  record_data->SetInteger("image_gathering_count",
-                          image_gathering_count);
-  return TracedValue::FromValue(record_data.release());
+                        total_tile_analysis_time.InSecondsF());
 }
 
-scoped_ptr<base::debug::ConvertableToTraceFormat>
-ImplThreadRenderingStats::AsTraceableData() const {
-  scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
-  record_data->SetInteger("screen_frame_count",
-                          screen_frame_count);
-  record_data->SetInteger("dropped_frame_count",
-                          dropped_frame_count);
-  record_data->SetDouble("rasterize_time",
-                         rasterize_time.InSecondsF());
-  record_data->SetDouble(
-      "rasterize_time_for_now_bins_on_pending_tree",
-      rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
-  record_data->SetDouble("best_rasterize_time",
-                         best_rasterize_time.InSecondsF());
-  record_data->SetInteger("rasterized_pixel_count",
-                          rasterized_pixel_count);
-  record_data->SetInteger("impl_thread_scroll_count",
-                          impl_thread_scroll_count);
-  record_data->SetInteger("main_thread_scroll_count",
-                          main_thread_scroll_count);
-  record_data->SetInteger("drawn_layer_count",
-                          drawn_layer_count);
-  record_data->SetInteger("missing_tile_count",
-                          missing_tile_count);
-  record_data->SetInteger("deferred_image_decode_count",
-                          deferred_image_decode_count);
-  record_data->SetInteger("deferred_image_cache_hit_count",
-                          deferred_image_cache_hit_count);
-  record_data->SetInteger("tile_analysis_count",
-                          tile_analysis_count);
-  record_data->SetInteger("solid_color_tile_analysis_count",
-                          solid_color_tile_analysis_count);
-  record_data->SetDouble("deferred_image_decode_time",
-                         deferred_image_decode_time.InSecondsF());
-  record_data->SetDouble("tile_analysis_time",
-                         tile_analysis_time.InSecondsF());
-  return TracedValue::FromValue(record_data.release());
-}
-
-
-void MainThreadRenderingStats::Add(const MainThreadRenderingStats& other) {
+void RenderingStats::Add(const RenderingStats& other) {
   animation_frame_count += other.animation_frame_count;
   screen_frame_count += other.screen_frame_count;
-  paint_time += other.paint_time;
-  record_time += other.record_time;
-  commit_time += other.commit_time;
-  commit_count += other.commit_count;
-  painted_pixel_count += other.painted_pixel_count;
-  recorded_pixel_count += other.recorded_pixel_count;
-  image_gathering_count += other.image_gathering_count;
-  image_gathering_time += other.image_gathering_time;
-}
-
-void ImplThreadRenderingStats::Add(const ImplThreadRenderingStats& other) {
-  screen_frame_count += other.screen_frame_count;
   dropped_frame_count += other.dropped_frame_count;
-  rasterize_time += other.rasterize_time;
-  rasterize_time_for_now_bins_on_pending_tree +=
-      other.rasterize_time_for_now_bins_on_pending_tree;
+  total_paint_time += other.total_paint_time;
+  total_record_time += other.total_record_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;
   best_rasterize_time += other.best_rasterize_time;
-  rasterized_pixel_count += other.rasterized_pixel_count;
-  impl_thread_scroll_count += other.impl_thread_scroll_count;
-  main_thread_scroll_count += other.main_thread_scroll_count;
-  drawn_layer_count += other.drawn_layer_count;
-  missing_tile_count += other.missing_tile_count;
-  deferred_image_decode_count += other.deferred_image_decode_count;
-  deferred_image_cache_hit_count += other.deferred_image_cache_hit_count;
-  deferred_image_decode_time += other.deferred_image_decode_time;
-  tile_analysis_count += other.tile_analysis_count;
-  solid_color_tile_analysis_count += other.solid_color_tile_analysis_count;
-  tile_analysis_time += other.tile_analysis_time;
-}
-
-void RenderingStats::Add(const RenderingStats& other) {
-  main_stats.Add(other.main_stats);
-  impl_stats.Add(other.impl_stats);
+  total_commit_count += other.total_commit_count;
+  total_pixels_painted += other.total_pixels_painted;
+  total_pixels_recorded += other.total_pixels_recorded;
+  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;
+  total_tiles_analyzed += other.total_tiles_analyzed;
+  solid_color_tiles_analyzed += other.solid_color_tiles_analyzed;
+  total_tile_analysis_time += other.total_tile_analysis_time;
 }
 
 }  // namespace cc
diff --git a/cc/debug/rendering_stats.h b/cc/debug/rendering_stats.h
index 8b9455d..eb01a57 100644
--- a/cc/debug/rendering_stats.h
+++ b/cc/debug/rendering_stats.h
@@ -8,79 +8,55 @@
 #include "base/basictypes.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
-#include "cc/debug/traced_value.h"
 
 namespace cc {
 
-// 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 RenderingStatsEnumerator {
- 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 ~RenderingStatsEnumerator() {}
-};
-
-struct CC_EXPORT MainThreadRenderingStats {
-  // Note: when adding new members, please remember to update EnumerateFields
-  // and Add in rendering_stats.cc.
-
+struct CC_EXPORT RenderingStats {
   int64 animation_frame_count;
   int64 screen_frame_count;
-  base::TimeDelta paint_time;
-  base::TimeDelta record_time;
-  base::TimeDelta commit_time;
-  int64 commit_count;
-  int64 painted_pixel_count;
-  int64 recorded_pixel_count;
-  int64 image_gathering_count;
-  base::TimeDelta image_gathering_time;
-
-  MainThreadRenderingStats();
-  void EnumerateFields(RenderingStatsEnumerator* enumerator) const;
-  scoped_ptr<base::debug::ConvertableToTraceFormat> AsTraceableData() const;
-  void Add(const MainThreadRenderingStats& other);
-};
-
-struct CC_EXPORT ImplThreadRenderingStats {
-  // Note: when adding new members, please remember to update EnumerateFields
-  // and Add in rendering_stats.cc.
-
-  int64 screen_frame_count;
   int64 dropped_frame_count;
-  base::TimeDelta rasterize_time;
-  base::TimeDelta rasterize_time_for_now_bins_on_pending_tree;
+  base::TimeDelta total_paint_time;
+  base::TimeDelta total_record_time;
+  base::TimeDelta total_rasterize_time;
+  base::TimeDelta total_rasterize_time_for_now_bins_on_pending_tree;
+  base::TimeDelta total_commit_time;
   base::TimeDelta best_rasterize_time;
-  int64 rasterized_pixel_count;
-  int64 impl_thread_scroll_count;
-  int64 main_thread_scroll_count;
-  int64 drawn_layer_count;
-  int64 missing_tile_count;
-  int64 deferred_image_decode_count;
-  int64 deferred_image_cache_hit_count;
-  int64 tile_analysis_count;
-  int64 solid_color_tile_analysis_count;
-  base::TimeDelta deferred_image_decode_time;
-  base::TimeDelta tile_analysis_time;
-
-  ImplThreadRenderingStats();
-  void EnumerateFields(RenderingStatsEnumerator* enumerator) const;
-  scoped_ptr<base::debug::ConvertableToTraceFormat> AsTraceableData() const;
-  void Add(const ImplThreadRenderingStats& other);
-};
-
-struct CC_EXPORT RenderingStats {
-  typedef RenderingStatsEnumerator Enumerator;
+  int64 total_commit_count;
+  int64 total_pixels_painted;
+  int64 total_pixels_recorded;
+  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;
+  int64 total_tiles_analyzed;
+  int64 solid_color_tiles_analyzed;
+  base::TimeDelta total_deferred_image_decode_time;
+  base::TimeDelta total_image_gathering_time;
+  base::TimeDelta total_tile_analysis_time;
+  // Note: when adding new members, please remember to update EnumerateFields
+  // and Add in rendering_stats.cc.
 
-  MainThreadRenderingStats main_stats;
-  ImplThreadRenderingStats impl_stats;
+  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;
+
+   protected:
+    virtual ~Enumerator() {}
+  };
 
   // Outputs the fields in this structure to the provided enumerator.
   void EnumerateFields(Enumerator* enumerator) const;
diff --git a/cc/debug/rendering_stats_instrumentation.cc b/cc/debug/rendering_stats_instrumentation.cc
index 3c164f9..b3886af 100644
--- a/cc/debug/rendering_stats_instrumentation.cc
+++ b/cc/debug/rendering_stats_instrumentation.cc
@@ -20,22 +20,7 @@ RenderingStatsInstrumentation::~RenderingStatsInstrumentation() {}
 
 RenderingStats RenderingStatsInstrumentation::GetRenderingStats() {
   base::AutoLock scoped_lock(lock_);
-  RenderingStats rendering_stats;
-  rendering_stats.main_stats = main_stats_accu_;
-  rendering_stats.main_stats.Add(main_stats_);
-  rendering_stats.impl_stats = impl_stats_accu_;
-  rendering_stats.impl_stats.Add(impl_stats_);
-  return rendering_stats;
-}
-
-void RenderingStatsInstrumentation::AccumulateAndClearMainThreadStats() {
-  main_stats_accu_.Add(main_stats_);
-  main_stats_ = MainThreadRenderingStats();
-}
-
-void RenderingStatsInstrumentation::AccumulateAndClearImplThreadStats() {
-  impl_stats_accu_.Add(impl_stats_);
-  impl_stats_ = ImplThreadRenderingStats();
+  return rendering_stats_;
 }
 
 base::TimeTicks RenderingStatsInstrumentation::StartRecording() const {
@@ -56,23 +41,23 @@ void RenderingStatsInstrumentation::IncrementAnimationFrameCount() {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  main_stats_.animation_frame_count++;
+  rendering_stats_.animation_frame_count++;
 }
 
-void RenderingStatsInstrumentation::IncrementScreenFrameCount(int64 count) {
+void RenderingStatsInstrumentation::SetScreenFrameCount(int64 count) {
   if (!record_rendering_stats_)
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.screen_frame_count += count;
+  rendering_stats_.screen_frame_count = count;
 }
 
-void RenderingStatsInstrumentation::IncrementDroppedFrameCount(int64 count) {
+void RenderingStatsInstrumentation::SetDroppedFrameCount(int64 count) {
   if (!record_rendering_stats_)
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.dropped_frame_count += count;
+  rendering_stats_.dropped_frame_count = count;
 }
 
 void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
@@ -80,8 +65,8 @@ void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  main_stats_.commit_time += duration;
-  main_stats_.commit_count++;
+  rendering_stats_.total_commit_time += duration;
+  rendering_stats_.total_commit_count++;
 }
 
 void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
@@ -90,8 +75,8 @@ void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
     return;
 
   base::AutoLock scoped_lock(lock_);
-  main_stats_.paint_time += duration;
-  main_stats_.painted_pixel_count += pixels;
+  rendering_stats_.total_paint_time += duration;
+  rendering_stats_.total_pixels_painted += pixels;
 }
 
 void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
@@ -100,8 +85,8 @@ void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
     return;
 
   base::AutoLock scoped_lock(lock_);
-  main_stats_.record_time += duration;
-  main_stats_.recorded_pixel_count += pixels;
+  rendering_stats_.total_record_time += duration;
+  rendering_stats_.total_pixels_recorded += pixels;
 }
 
 void RenderingStatsInstrumentation::AddRaster(base::TimeDelta total_duration,
@@ -112,12 +97,12 @@ void RenderingStatsInstrumentation::AddRaster(base::TimeDelta total_duration,
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.rasterize_time += total_duration;
-  impl_stats_.best_rasterize_time += best_duration;
-  impl_stats_.rasterized_pixel_count += pixels;
+  rendering_stats_.total_rasterize_time += total_duration;
+  rendering_stats_.best_rasterize_time += best_duration;
+  rendering_stats_.total_pixels_rasterized += pixels;
 
   if (is_in_pending_tree_now_bin) {
-    impl_stats_.rasterize_time_for_now_bins_on_pending_tree +=
+    rendering_stats_.total_rasterize_time_for_now_bins_on_pending_tree +=
         total_duration;
   }
 }
@@ -127,7 +112,7 @@ void RenderingStatsInstrumentation::IncrementImplThreadScrolls() {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.impl_thread_scroll_count++;
+  rendering_stats_.num_impl_thread_scrolls++;
 }
 
 void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
@@ -135,7 +120,7 @@ void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.main_thread_scroll_count++;
+  rendering_stats_.num_main_thread_scrolls++;
 }
 
 void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
@@ -143,7 +128,7 @@ void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.drawn_layer_count += amount;
+  rendering_stats_.num_layers_drawn += amount;
 }
 
 void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
@@ -151,7 +136,7 @@ void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.missing_tile_count += amount;
+  rendering_stats_.num_missing_tiles += amount;
 }
 
 void RenderingStatsInstrumentation::AddDeferredImageDecode(
@@ -160,8 +145,8 @@ void RenderingStatsInstrumentation::AddDeferredImageDecode(
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.deferred_image_decode_time += duration;
-  impl_stats_.deferred_image_decode_count++;
+  rendering_stats_.total_deferred_image_decode_time += duration;
+  rendering_stats_.total_deferred_image_decode_count++;
 }
 
 void RenderingStatsInstrumentation::AddImageGathering(
@@ -170,8 +155,8 @@ void RenderingStatsInstrumentation::AddImageGathering(
     return;
 
   base::AutoLock scoped_lock(lock_);
-  main_stats_.image_gathering_time += duration;
-  main_stats_.image_gathering_count++;
+  rendering_stats_.total_image_gathering_time += duration;
+  rendering_stats_.total_image_gathering_count++;
 }
 
 void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
@@ -179,7 +164,7 @@ void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.deferred_image_cache_hit_count++;
+  rendering_stats_.total_deferred_image_cache_hit_count++;
 }
 
 void RenderingStatsInstrumentation::AddAnalysisResult(
@@ -189,10 +174,10 @@ void RenderingStatsInstrumentation::AddAnalysisResult(
     return;
 
   base::AutoLock scoped_lock(lock_);
-  impl_stats_.tile_analysis_count++;
-  impl_stats_.tile_analysis_time += duration;
+  rendering_stats_.total_tiles_analyzed++;
+  rendering_stats_.total_tile_analysis_time += duration;
   if (is_solid_color)
-    impl_stats_.solid_color_tile_analysis_count++;
+    rendering_stats_.solid_color_tiles_analyzed++;
 }
 
 }  // namespace cc
diff --git a/cc/debug/rendering_stats_instrumentation.h b/cc/debug/rendering_stats_instrumentation.h
index a7f9b308..6f7515a 100644
--- a/cc/debug/rendering_stats_instrumentation.h
+++ b/cc/debug/rendering_stats_instrumentation.h
@@ -18,24 +18,8 @@ class CC_EXPORT RenderingStatsInstrumentation {
   static scoped_ptr<RenderingStatsInstrumentation> Create();
   virtual ~RenderingStatsInstrumentation();
 
-  // Return current main thread rendering stats.
-  MainThreadRenderingStats GetMainThreadRenderingStats() {
-    return main_stats_;
-  }
-  // Return current impl thread rendering stats.
-  ImplThreadRenderingStats GetImplThreadRenderingStats() {
-    return impl_stats_;
-  }
-  // Return the accumulated, combined rendering stats.
   RenderingStats GetRenderingStats();
 
-  // Add current main thread rendering stats to accumulator and
-  // clear current stats
-  void AccumulateAndClearMainThreadStats();
-  // Add current impl thread rendering stats to accumulator and
-  // clear current stats
-  void AccumulateAndClearImplThreadStats();
-
   // Read and write access to the record_rendering_stats_ flag is not locked to
   // improve performance. The flag is commonly turned off and hardly changes
   // it's value during runtime.
@@ -49,8 +33,8 @@ class CC_EXPORT RenderingStatsInstrumentation {
   base::TimeDelta EndRecording(base::TimeTicks start_time) const;
 
   void IncrementAnimationFrameCount();
-  void IncrementScreenFrameCount(int64 count);
-  void IncrementDroppedFrameCount(int64 count);
+  void SetScreenFrameCount(int64 count);
+  void SetDroppedFrameCount(int64 count);
 
   void AddCommit(base::TimeDelta duration);
   void AddPaint(base::TimeDelta duration, int64 pixels);
@@ -77,11 +61,7 @@ class CC_EXPORT RenderingStatsInstrumentation {
   RenderingStatsInstrumentation();
 
  private:
-  MainThreadRenderingStats main_stats_;
-  MainThreadRenderingStats main_stats_accu_;
-  ImplThreadRenderingStats impl_stats_;
-  ImplThreadRenderingStats impl_stats_accu_;
-
+  RenderingStats rendering_stats_;
   bool record_rendering_stats_;
 
   base::Lock lock_;