Move RenderStats enumeration out of gpu_benchmarking_extension.

With this patch, we won't have to keep modifying gpu_benchmarking_extension when
we add new fields to RenderStats.

BUG=163073


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

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

cc/rendering_stats.cc

@@ -21,4 +21,20 @@ RenderingStats::RenderingStats()
       numLayersDrawn(0) {
 }
 
+void RenderingStats::EnumerateFields(Enumerator* enumerator) const {
+    enumerator->AddInt64("numAnimationFrames", numAnimationFrames);
+    enumerator->AddInt64("numFramesSentToScreen", numFramesSentToScreen);
+    enumerator->AddInt64("droppedFrameCount", droppedFrameCount);
+    enumerator->AddDouble("totalPaintTimeInSeconds", totalPaintTimeInSeconds);
+    enumerator->AddDouble("totalRasterizeTimeInSeconds",
+                          totalRasterizeTimeInSeconds);
+    enumerator->AddDouble("totalCommitTimeInSeconds", totalCommitTimeInSeconds);
+    enumerator->AddInt64("totalCommitCount", totalCommitCount);
+    enumerator->AddInt64("totalPixelsPainted", totalPixelsPainted);
+    enumerator->AddInt64("totalPixelsRasterized", totalPixelsRasterized);
+    enumerator->AddInt64("numImplThreadScrolls", numImplThreadScrolls);
+    enumerator->AddInt64("numMainThreadScrolls", numMainThreadScrolls);
+    enumerator->AddInt64("numLayersDrawn", numLayersDrawn);
+}
+
 }  // namespace cc

cc/rendering_stats.h

@@ -6,6 +6,7 @@
 #define CC_RENDERING_STATS_H_
 
 #include "base/basictypes.h"
+#include "base/time.h"
 #include "cc/cc_export.h"
 
 namespace cc {
@@ -24,8 +25,29 @@ struct CC_EXPORT RenderingStats {
     int64 numImplThreadScrolls;
     int64 numMainThreadScrolls;
     int64 numLayersDrawn;
+    // Note: when adding new members, please remember to update enumerateFields
+    // in rendering_stats.cc.
 
     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;
 };
 
 }  // namespace cc

content/common/gpu/gpu_rendering_stats.cc

@@ -14,4 +14,19 @@ GpuRenderingStats::GpuRenderingStats()
 GpuRenderingStats::~GpuRenderingStats() {
 }
 
+void GpuRenderingStats::EnumerateFields(
+    cc::RenderingStats::Enumerator* enumerator) const {
+  enumerator->AddInt("globalTextureUploadCount", global_texture_upload_count);
+  enumerator->AddTimeDeltaInSecondsF("globalTotalTextureUploadTimeInSeconds",
+                                     global_total_texture_upload_time);
+  enumerator->AddInt("textureUploadCount", texture_upload_count);
+  enumerator->AddTimeDeltaInSecondsF("totalTextureUploadTimeInSeconds",
+                           total_texture_upload_time);
+  enumerator->AddTimeDeltaInSecondsF(
+      "globalTotalProcessingCommandsTimeInSeconds",
+      global_total_processing_commands_time);
+  enumerator->AddTimeDeltaInSecondsF("totalProcessingCommandsTimeInSeconds",
+                                     total_processing_commands_time);
+}
+
 }  // namespace content

content/common/gpu/gpu_rendering_stats.h

@@ -6,6 +6,7 @@
 #define CONTENT_COMMON_GPU_GPU_RENDERING_STATS_H_
 
 #include "base/time.h"
+#include "cc/rendering_stats.h"
 #include "content/common/content_export.h"
 
 namespace content {
@@ -20,6 +21,11 @@ struct CONTENT_EXPORT GpuRenderingStats {
   base::TimeDelta total_texture_upload_time;
   base::TimeDelta global_total_processing_commands_time;
   base::TimeDelta total_processing_commands_time;
+  // Note: when adding new members, please remember to update enumerateFields
+  // in gpu_rendering_stats.cc.
+
+  // Outputs the fields in this structure to the provided enumerator.
+  void EnumerateFields(cc::RenderingStats::Enumerator* enumerator) const;
 };
 
 }  // namespace content

content/renderer/gpu/gpu_benchmarking_extension.cc

@@ -81,6 +81,33 @@ class SkPictureRecorder : public WebViewBenchmarkSupport::PaintClient {
   SkPicture picture_;
 };
 
+class RenderingStatsEnumerator : public cc::RenderingStats::Enumerator {
+ public:
+  RenderingStatsEnumerator(v8::Handle<v8::Object> stats_object)
+      : stats_object(stats_object) { }
+
+  virtual void AddInt64(const char* name, int64 value) {
+    stats_object->Set(v8::String::New(name), v8::Number::New(value));
+  }
+
+  virtual void AddDouble(const char* name, double value) {
+    stats_object->Set(v8::String::New(name), v8::Number::New(value));
+  }
+
+  virtual void AddInt(const char* name, int value) {
+    stats_object->Set(v8::String::New(name), v8::Integer::New(value));
+  }
+
+  virtual void AddTimeDeltaInSecondsF(const char* name,
+                                      const base::TimeDelta& value) {
+    stats_object->Set(v8::String::New(name),
+                      v8::Number::New(value.InSecondsF()));
+  }
+
+ private:
+  v8::Handle<v8::Object> stats_object;
+};
+
 }  // namespace
 
 namespace content {
@@ -158,62 +185,11 @@ class GpuBenchmarkingWrapper : public v8::Extension {
     content::GpuRenderingStats gpu_stats;
     render_view_impl->GetGpuRenderingStats(&gpu_stats);
     v8::Handle<v8::Object> stats_object = v8::Object::New();
-    stats_object->Set(v8::String::New("numAnimationFrames"),
-                      v8::Number::New(
-                          stats.rendering_stats.numAnimationFrames));
-    stats_object->Set(v8::String::New("numFramesSentToScreen"),
-                      v8::Number::New(
-                          stats.rendering_stats.numFramesSentToScreen));
-    stats_object->Set(v8::String::New("droppedFrameCount"),
-                      v8::Number::New(
-                          stats.rendering_stats.droppedFrameCount));
-    stats_object->Set(v8::String::New("totalPaintTimeInSeconds"),
-                      v8::Number::New(
-                          stats.rendering_stats.totalPaintTimeInSeconds));
-    stats_object->Set(v8::String::New("totalRasterizeTimeInSeconds"),
-                      v8::Number::New(
-                          stats.rendering_stats.totalRasterizeTimeInSeconds));
-    stats_object->Set(v8::String::New("totalCommitTimeInSeconds"),
-                      v8::Number::New(
-                          stats.rendering_stats.totalCommitTimeInSeconds));
-    stats_object->Set(v8::String::New("totalCommitCount"),
-                      v8::Number::New(
-                          stats.rendering_stats.totalCommitCount));
-    stats_object->Set(v8::String::New("numImplThreadScrolls"),
-                      v8::Number::New(
-                          stats.rendering_stats.numImplThreadScrolls));
-    stats_object->Set(v8::String::New("numMainThreadScrolls"),
-                      v8::Number::New(
-                          stats.rendering_stats.numMainThreadScrolls));
-    stats_object->Set(v8::String::New("totalPixelsPainted"),
-                      v8::Number::New(
-                          stats.rendering_stats.totalPixelsPainted));
-    stats_object->Set(v8::String::New("totalPixelsRasterized"),
-                      v8::Number::New(
-                          stats.rendering_stats.totalPixelsRasterized));
-    stats_object->Set(v8::String::New("numLayersDrawn"),
-                      v8::Number::New(
-                          stats.rendering_stats.numLayersDrawn));
-
-    stats_object->Set(v8::String::New("globalTextureUploadCount"),
-                      v8::Number::New(gpu_stats.global_texture_upload_count));
-    stats_object->Set(
-        v8::String::New("globalTotalTextureUploadTimeInSeconds"),
-        v8::Number::New(
-            gpu_stats.global_total_texture_upload_time.InSecondsF()));
-    stats_object->Set(v8::String::New("textureUploadCount"),
-                      v8::Number::New(gpu_stats.texture_upload_count));
-    stats_object->Set(
-        v8::String::New("totalTextureUploadTimeInSeconds"),
-        v8::Number::New(gpu_stats.total_texture_upload_time.InSecondsF()));
-    stats_object->Set(
-        v8::String::New("globalTotalProcessingCommandsTimeInSeconds"),
-        v8::Number::New(
-            gpu_stats.global_total_processing_commands_time.InSecondsF()));
-    stats_object->Set(
-        v8::String::New("totalProcessingCommandsTimeInSeconds"),
-        v8::Number::New(
-            gpu_stats.total_processing_commands_time.InSecondsF()));
+
+    RenderingStatsEnumerator enumerator(stats_object);
+    stats.rendering_stats.EnumerateFields(&enumerator);
+    gpu_stats.EnumerateFields(&enumerator);
+
     return stats_object;
   }