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

content/renderer/all_rendering_benchmarks.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/all_rendering_benchmarks.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "content/renderer/rendering_benchmark.h"
-#include "content/renderer/rendering_benchmark_results.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/utils/SkNullCanvas.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebViewBenchmarkSupport.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using WebKit::WebSize;
@@ skipping 19 matching lines @@
     WebCanvas* canvas = createCanvas(size);
     before_time_ = TimeTicks::HighResNow();
     return canvas;
   }
 
   virtual void didPaint(WebCanvas* canvas) OVERRIDE {
     paint_time_total_ += (TimeTicks::HighResNow() - before_time_);
     delete canvas;
   }
 
-  virtual void Run(content::RenderingBenchmarkResults* results,
-                   WebViewBenchmarkSupport* support) OVERRIDE {
+  virtual double Run(WebViewBenchmarkSupport* support) OVERRIDE {
     paint_time_total_ = TimeDelta();
     support->paint(this, paint_mode_);
-    results->AddResult(name(),
-                       "paintTime",
-                       "s",
-                       paint_time_total_.InSecondsF());
+    return paint_time_total_.InMillisecondsF();

[piman, 2012/08/20 17:58:56]

did you intend to switch from seconds to milliseconds here (and below)?

[dmurph, 2012/08/20 19:30:08]

Yeah, that's intended.

   }
 
  private:
   virtual WebCanvas* createCanvas(const WebSize& size) = 0;
 
   TimeTicks before_time_;
   TimeDelta paint_time_total_;
   const WebViewBenchmarkSupport::PaintMode paint_mode_;
 };
 
 class BitmapCanvasPaintBenchmark : public CustomPaintBenchmark {
  public:
   BitmapCanvasPaintBenchmark(const std::string& name,
                              WebViewBenchmarkSupport::PaintMode paint_mode)
       : CustomPaintBenchmark(name, paint_mode) { }
 
  private:
   virtual WebCanvas* createCanvas(const WebSize& size) OVERRIDE {
     return skia::CreateBitmapCanvas(size.width, size.height, false);
   }
 };
 
+class CanvasCountBenchmark
+    : public content::RenderingBenchmark,
+      public WebViewBenchmarkSupport::PaintClient {
+ public:
+  CanvasCountBenchmark(const std::string& name,
+                       WebViewBenchmarkSupport::PaintMode paint_mode)
+      : content::RenderingBenchmark(name),
+        canvas_count_(0),
+        paint_mode_(paint_mode) { }
+
+  virtual WebCanvas* willPaint(const WebSize& size) OVERRIDE {
+    ++canvas_count_;
+    return SkCreateNullCanvas();
+  }
+
+  virtual void didPaint(WebCanvas* canvas) OVERRIDE {
+    delete canvas;
+  }
+
+  virtual double Run(WebViewBenchmarkSupport* support) OVERRIDE {
+    canvas_count_ = 0;
+    support->paint(this, paint_mode_);
+    return canvas_count_;
+  }
+ private:
+  int canvas_count_;
+  const WebViewBenchmarkSupport::PaintMode paint_mode_;
+};
+
 class NullCanvasPaintBenchmark : public CustomPaintBenchmark {
  public:
   NullCanvasPaintBenchmark(const std::string& name,
                            WebViewBenchmarkSupport::PaintMode paint_mode)
-      : CustomPaintBenchmark(name, paint_mode),
-        canvas_count_(0) { }
-
-  virtual void Run(content::RenderingBenchmarkResults* results,
-                   WebViewBenchmarkSupport* support) OVERRIDE {
-    canvas_count_ = 0;
-    CustomPaintBenchmark::Run(results, support);
-    results->AddResult(name(),
-                       "canvasCount",
-                       "i",
-                       canvas_count_);
-  }
+      : CustomPaintBenchmark(name, paint_mode) { }
 
  private:
   virtual WebCanvas* createCanvas(const WebSize& size) OVERRIDE {
-    ++canvas_count_;
     return SkCreateNullCanvas();
   }
-
-  int canvas_count_;
 };
 
 class SkPicturePaintBenchmark : public CustomPaintBenchmark {
  public:
   SkPicturePaintBenchmark(const std::string& name,
                           WebViewBenchmarkSupport::PaintMode paint_mode)
       : CustomPaintBenchmark(name, paint_mode) { }
 
   virtual void didPaint(WebCanvas* canvas) OVERRIDE {
     DCHECK(picture_.getRecordingCanvas() == canvas);
@@ skipping 35 matching lines @@
       WebRect tile = *it;
       scoped_ptr<WebCanvas> canvas(
           skia::CreateBitmapCanvas(tile.width, tile.height, false));
       TimeTicks before_time = TimeTicks::HighResNow();
       canvas->translate(-tile.x, -tile.y);
       picture_.draw(canvas.get());
       paint_time_total_ += (TimeTicks::HighResNow() - before_time);
     }
   }
 
-  virtual void Run(content::RenderingBenchmarkResults* results,
-                   WebViewBenchmarkSupport* support) {
+  virtual double Run(WebViewBenchmarkSupport* support) {
     paint_time_total_ = TimeDelta();
     support->paint(this, paint_mode_);
-    results->AddResult(name(),
-                       "repaintTime",
-                       "s",
-                       paint_time_total_.InSecondsF());
+    return paint_time_total_.InMillisecondsF();
   }
 
  private:
   virtual vector<WebRect> GetRepaintTiles(const WebSize& layer_size) const = 0;
 
   TimeDelta paint_time_total_;
   SkPicture picture_;
   const WebViewBenchmarkSupport::PaintMode paint_mode_;
 };
 
@@ skipping 48 matching lines @@
   int tile_height_;
 };
 
 }  // anonymous namespace
 
 namespace content {
 
 ScopedVector<RenderingBenchmark> AllRenderingBenchmarks() {
   ScopedVector<RenderingBenchmark> benchmarks;
   benchmarks.push_back(new BitmapCanvasPaintBenchmark(
-      "PaintEverythingToBitmap",
+      "PaintEverythingToBitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything));
   benchmarks.push_back(new NullCanvasPaintBenchmark(
-      "PaintEverythingToNullCanvas",
+      "PaintEverythingToNullCanvasMs",
+      WebViewBenchmarkSupport::PaintModeEverything));
+  benchmarks.push_back(new CanvasCountBenchmark(
+      "LayerCount",
       WebViewBenchmarkSupport::PaintModeEverything));
   benchmarks.push_back(new SkPicturePaintBenchmark(
-      "PaintEverythingToSkPicture",
+      "PaintEverythingToSkPictureMs",
       WebViewBenchmarkSupport::PaintModeEverything));
   benchmarks.push_back(new SquareTiledReplayBenchmark(
-      "RepaintEverythingTo256x256Bitmap",
+      "RepaintEverythingTo256x256BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       256));
   benchmarks.push_back(new SquareTiledReplayBenchmark(
-      "RepaintEverythingTo128x128Bitmap",
+      "RepaintEverythingTo128x128BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       128));
   benchmarks.push_back(new SquareTiledReplayBenchmark(
-      "RepaintEverythingTo512x512Bitmap",
+      "RepaintEverythingTo512x512BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       512));
   benchmarks.push_back(new LayerWidthTiledReplayBenchmark(
-      "RepaintEverythingToLayerWidthx256Bitmap",
+      "RepaintEverythingToLayerWidthx256BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       256));
   benchmarks.push_back(new LayerWidthTiledReplayBenchmark(
-      "RepaintEverythingToLayerWidthx128Bitmap",
+      "RepaintEverythingToLayerWidthx128BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       128));
   benchmarks.push_back(new LayerWidthTiledReplayBenchmark(
-      "RepaintEverythingToLayerWidthx64Bitmap",
+      "RepaintEverythingToLayerWidthx64BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       64));
   benchmarks.push_back(new LayerWidthTiledReplayBenchmark(
-      "RepaintEverythingToLayerWidthx512Bitmap",
+      "RepaintEverythingToLayerWidthx512BitmapMs",
       WebViewBenchmarkSupport::PaintModeEverything,
       512));
   return benchmarks.Pass();
 }
 
 }  // namespace content