Move RenderStats enumeration out of gpu_benchmarking_extension.

content/renderer/gpu/gpu_benchmarking_extension.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/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 63 matching lines @@
     DCHECK(file.isValid());
     picture_.serialize(&file);
   }
 
  private:
   FilePath dirpath_;
   int layer_id_;
   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 {
 
 class GpuBenchmarkingWrapper : public v8::Extension {
  public:
   GpuBenchmarkingWrapper() :
       v8::Extension(kGpuBenchmarkingExtensionName,
           "if (typeof(chrome) == 'undefined') {"
           "  chrome = {};"
@@ skipping 57 matching lines @@
     RenderViewImpl* render_view_impl = RenderViewImpl::FromWebView(web_view);
     if (!render_view_impl)
       return v8::Undefined();
 
     WebRenderingStatsImpl stats;
     render_view_impl->GetRenderingStats(stats);
 
     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;
   }
 
   static v8::Handle<v8::Value> PrintToSkPicture(const v8::Arguments& args) {
     if (args.Length() != 1)
       return v8::Undefined();
 
     v8::String::AsciiValue dirname(args[0]);
     if (dirname.length() == 0)
       return v8::Undefined();
@@ skipping 159 matching lines @@
 
     return results;
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content