Removed benchmark results object from rendering benchmarks, now one result per benchmark

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"
 #include "base/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/all_rendering_benchmarks.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/rendering_benchmark.h"
-#include "content/renderer/rendering_benchmark_results.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRenderingStats.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebViewBenchmarkSupport.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebCanvas;
@@ skipping 50 matching lines @@
  private:
   FilePath dirpath_;
   int layer_id_;
   SkPicture picture_;
 };
 
 }  // namespace
 
 namespace content {
 
-// Benchmark results object that populates a v8 array.
-class V8BenchmarkResults : public content::RenderingBenchmarkResults {
- public:
-  explicit V8BenchmarkResults()
-    : results_array_(v8::Array::New(0)) { }
-  virtual ~V8BenchmarkResults() {}
-
-  void AddResult(const std::string& benchmark_name,
-                 const std::string& result_name,
-                 const std::string& result_unit,
-                 double result) {
-    v8::Handle<v8::Object> result_object = v8::Object::New();
-    result_object->Set(v8::String::New("benchmarkName", 13),
-                       v8::String::New(benchmark_name.c_str(), -1));
-    result_object->Set(v8::String::New("resultName", 10),
-                       v8::String::New(result_name.c_str(), -1));
-    result_object->Set(v8::String::New("resultUnit", 10),
-                       v8::String::New(result_unit.c_str(), -1));
-    result_object->Set(v8::String::New("result", 6), v8::Number::New(result));
-
-    results_array_->Set(results_array_->Length(), result_object);
-  }
-
-  v8::Handle<v8::Array> results_array() {
-    return results_array_;
-  }
-
- private:
-  v8::Handle<v8::Array> results_array_;
-};
-
 class GpuBenchmarkingWrapper : public v8::Extension {
  public:
   GpuBenchmarkingWrapper() :
       v8::Extension(kGpuBenchmarkingExtensionName,
           "if (typeof(chrome) == 'undefined') {"
           "  chrome = {};"
           "};"
           "if (typeof(chrome.gpuBenchmarking) == 'undefined') {"
           "  chrome.gpuBenchmarking = {};"
           "};"
@@ skipping 186 matching lines @@
     WebView* web_view = web_frame->view();
     if (!web_view)
       return v8::Undefined();
 
     WebViewBenchmarkSupport* support = web_view->benchmarkSupport();
     if (!support)
       return v8::Undefined();
 
     ScopedVector<RenderingBenchmark> benchmarks = AllRenderingBenchmarks();
 
-    V8BenchmarkResults results;
+    v8::Handle<v8::Array> results = v8::Array::New(0);
     ScopedVector<RenderingBenchmark>::const_iterator it;
     for (it = benchmarks.begin(); it != benchmarks.end(); it++) {
       RenderingBenchmark* benchmark = *it;
       const std::string& name = benchmark->name();
       if (name_filter != "" &&
           std::string::npos == name.find(name_filter)) {
         continue;
       }
       benchmark->SetUp(support);
-      benchmark->Run(&results, support);
+      double result = benchmark->Run(support);
       benchmark->TearDown(support);
+
+      v8::Handle<v8::Object> result_object = v8::Object::New();
+      result_object->Set(v8::String::New("benchmark", 9),
+                         v8::String::New(name.c_str(), -1));
+      result_object->Set(v8::String::New("result", 6), v8::Number::New(result));
+      results->Set(results->Length(), result_object);
     }
 
-    return results.results_array();
+    return results;
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content