Report viewport memory and timing correctly for Slimming Paint.

cc/debug/rasterize_and_record_benchmark.cc

 // Copyright 2013 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 "cc/debug/rasterize_and_record_benchmark.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #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"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 71 matching lines @@
 
 void RasterizeAndRecordBenchmark::Run(Layer* layer) {
   layer->RunMicroBenchmark(this);
 }
 
 void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
   ContentLayerClient* painter = layer->client();
   gfx::Size content_bounds = layer->content_bounds();
 
   DCHECK(host_);
+
+  if (host_->settings().use_display_lists) {
+    RunOnDisplayListLayer(layer);

[ajuma, 2015/01/23 20:10:19]

Perhaps also define a RunOnPicturePileLayer for the logic that's currently below
in RunOnLayer, and call that when use_display_lists is false?

+    return;
+  }
+
   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;
 
   for (int mode_index = 0; mode_index < Picture::RECORDING_MODE_COUNT;
        mode_index++) {
     Picture::RecordingMode mode =
         static_cast<Picture::RecordingMode>(mode_index);
     base::TimeDelta min_time = base::TimeDelta::Max();
     size_t memory_used = 0;
 
     // Parameters for LapTimer.
     const int kTimeLimitMillis = 1;
     const int kWarmupRuns = 0;
     const int kTimeCheckInterval = 1;
 
     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);
       scoped_refptr<Picture> picture;
       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) {
       record_results_.bytes_used += memory_used;
       record_results_.pixels_recorded +=
           visible_content_rect.width() * visible_content_rect.height();
     }
     record_results_.total_best_time[mode_index] += min_time;
   }
 }
 
+void RasterizeAndRecordBenchmark::RunOnDisplayListLayer(PictureLayer* layer) {
+  ContentLayerClient* painter = layer->client();
+  gfx::Size content_bounds = layer->content_bounds();
+
+  DCHECK(host_ && host_->settings().use_display_lists);
+
+  gfx::Rect visible_content_rect = gfx::ScaleToEnclosingRect(

[vmpstr, 2015/01/23 20:03:06]

nit: Can you make this calculation a separate function, so that we can be sure
we're always measuring the same visible_content_rect (with and without display
lists). I'm worried that it's too easy to change one right now and forget about
the other. Either that or take visible_content_rect as a parameter and move the
call to this function lower.

+      layer->visible_content_rect(), 1.f / layer->contents_scale_x());
+  if (visible_content_rect.IsEmpty())
+    return;
+
+  // TODO(schenney): There is no real correspondence between the existing
+  // Picture::RecordingMode enum and DisplayItemList recording. We need to
+  // rethink it and create an appropriate set of modes.
+  base::TimeDelta min_time = base::TimeDelta::Max();
+  size_t memory_used = 0;
+
+  // Parameters for LapTimer.
+  const int kTimeLimitMillis = 1;
+  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 {
+      display_list = painter->PaintContentsToDisplayList(

[ajuma, 2015/01/23 20:10:19]

Will this actually cause the display list to be re-created every time in Blink?
(Is this where we need the "flush display item caches" method you mentioned in
the bug?)

+          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();
+  }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 
 }  // namespace cc