Report viewport memory and timing correctly for Slimming Paint.

cc/debug/rasterize_and_record_benchmark.cc

Index: cc/debug/rasterize_and_record_benchmark.cc
diff --git a/cc/debug/rasterize_and_record_benchmark.cc b/cc/debug/rasterize_and_record_benchmark.cc
index 51edc985a49338cdf619ea38121d53b380348b44..0e42d436609173cf8099184570bd96062cb5a2f6 100644
--- a/cc/debug/rasterize_and_record_benchmark.cc
+++ b/cc/debug/rasterize_and_record_benchmark.cc
@@ -13,8 +13,10 @@
 #include "base/values.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/debug/rasterize_and_record_benchmark_impl.h"
+#include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
+#include "cc/resources/display_item_list.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
@@ -102,17 +104,29 @@ void RasterizeAndRecordBenchmark::Run(Layer* layer) {
 }
 
 void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
-  ContentLayerClient* painter = layer->client();
-  gfx::Size content_bounds = layer->content_bounds();
-
   DCHECK(host_);
-  gfx::Size tile_grid_size = host_->settings().default_tile_size;
 
   gfx::Rect visible_content_rect = gfx::ScaleToEnclosingRect(
       layer->visible_content_rect(), 1.f / layer->contents_scale_x());
   if (visible_content_rect.IsEmpty())
     return;
 
+  if (host_->settings().use_display_lists) {
+    RunOnDisplayListLayer(layer, visible_content_rect);
+  } else {
+    RunOnPictureLayer(layer, visible_content_rect);
+  }
+}
+
+void RasterizeAndRecordBenchmark::RunOnPictureLayer(
+    PictureLayer* layer,
+    const gfx::Rect& visible_content_rect) {
+  ContentLayerClient* painter = layer->client();
+
+  DCHECK(host_ && !host_->settings().use_display_lists);
+
+  gfx::Size tile_grid_size = host_->settings().default_tile_size;
+
   for (int mode_index = 0; mode_index < Picture::RECORDING_MODE_COUNT;
        mode_index++) {
     Picture::RecordingMode mode =
@@ -135,13 +149,19 @@ void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
       do {
         picture = Picture::Create(visible_content_rect, painter, tile_grid_size,
                                   false, mode);
+        if (memory_used) {
+          // Verify we are recording the same thing each time.
+          DCHECK(memory_used == picture->ApproximateMemoryUsage());
+        } else {
+          memory_used = picture->ApproximateMemoryUsage();
+        }
+
         timer.NextLap();
       } while (!timer.HasTimeLimitExpired());
       base::TimeDelta duration =
           base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
       if (duration < min_time)
         min_time = duration;
-      memory_used = picture->ApproximateMemoryUsage();
     }
 
     if (mode == Picture::RECORD_NORMALLY) {
@@ -153,8 +173,69 @@ void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
   }
 }
 
+void RasterizeAndRecordBenchmark::RunOnDisplayListLayer(
+    PictureLayer* layer,
+    const gfx::Rect& visible_content_rect) {
+  ContentLayerClient* painter = layer->client();
+
+  DCHECK(host_ && host_->settings().use_display_lists);
+
+  base::TimeDelta min_time = base::TimeDelta::Max();
+  size_t memory_used = 0;
+
+  // Parameters for LapTimer.
+  const int kTimeLimitMillis = 1;

[vmpstr, 2015/01/27 22:57:32]

nit: You can move this to anonymous namespace

[Stephen Chennney, 2015/01/28 00:24:08]

Done.

+  const int kWarmupRuns = 0;
+  const int kTimeCheckInterval = 1;
+
+  // TODO(schenney): What are the corresponding Picture::RecordingMode modes
+  // for Slimming Paint. We could disable SkPicture creation in
+  // DrawingDisplayItems, or we could only generate the display list and not
+  // do any work on it in the compositor, or something else, or all of the
+  // above.
+  scoped_refptr<DisplayItemList> display_list;
+  for (int i = 0; i < record_repeat_count_; ++i) {
+    // Run for a minimum amount of time to avoid problems with timer
+    // quantization when the layer is very small.
+    LapTimer timer(kWarmupRuns,
+                   base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
+                   kTimeCheckInterval);
+
+    do {
+      // TODO(schenney): Cached content will not be regenerated, which skews
+      // the results significantly in favor of Slimming Paint (or should).
+      // Add a flag or API call to disable caching, and maybe run the test
+      // twice, without and with caching.
+      display_list = painter->PaintContentsToDisplayList(
+          visible_content_rect, ContentLayerClient::GRAPHICS_CONTEXT_ENABLED);
+
+      if (memory_used) {
+        // Verify we are recording the same thing each time.
+        DCHECK(memory_used == display_list->PictureMemoryUsage());
+      } else {
+        memory_used = display_list->PictureMemoryUsage();
+      }
+
+      timer.NextLap();
+    } while (!timer.HasTimeLimitExpired());
+    base::TimeDelta duration =
+        base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
+    if (duration < min_time)
+      min_time = duration;
+  }
+
+  record_results_.bytes_used += memory_used;
+  record_results_.pixels_recorded +=
+      visible_content_rect.width() * visible_content_rect.height();
+  record_results_.total_best_time[Picture::RECORD_NORMALLY] += min_time;
+}
+
 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
     : pixels_recorded(0), bytes_used(0) {
+  for (int mode_index = 0; mode_index < Picture::RECORDING_MODE_COUNT;
+       mode_index++) {
+    total_best_time[mode_index] = base::TimeDelta();

[vmpstr, 2015/01/27 22:57:32]

nit: I don't think this is required?

[Stephen Chennney, 2015/01/28 00:24:08]

Done, and verified that you still see 0 in output.

+  }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}