[S.P.] Fix rasterize_and_record benchmark to include SkPicture playback time

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>
 
@@ skipping 87 matching lines @@
   return make_scoped_ptr(new RasterizeAndRecordBenchmarkImpl(
       origin_loop,
       settings_.get(),
       base::Bind(&RasterizeAndRecordBenchmark::RecordRasterResults,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
 void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
   DCHECK(host_);
 
-  gfx::Rect visible_content_rect = gfx::ScaleToEnclosingRect(
+  gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
       layer->visible_content_rect(), 1.f / layer->contents_scale_x());
-  if (visible_content_rect.IsEmpty())
+  if (visible_layer_rect.IsEmpty())
     return;
 
   if (host_->settings().use_display_lists) {
-    RunOnDisplayListLayer(layer, visible_content_rect);
+    RunOnDisplayListLayer(layer, visible_layer_rect);
   } else {
-    RunOnPictureLayer(layer, visible_content_rect);
+    RunOnPictureLayer(layer, visible_layer_rect);
   }
 }
 
 void RasterizeAndRecordBenchmark::RunOnPictureLayer(
     PictureLayer* layer,
-    const gfx::Rect& visible_content_rect) {
+    const gfx::Rect& visible_layer_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 < RecordingSource::RECORDING_MODE_COUNT;
        mode_index++) {
     RecordingSource::RecordingMode mode =
         static_cast<RecordingSource::RecordingMode>(mode_index);
     base::TimeDelta min_time = base::TimeDelta::Max();
     size_t memory_used = 0;
 
     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,
+        picture = Picture::Create(visible_layer_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;
     }
 
     if (mode == RecordingSource::RECORD_NORMALLY) {
       record_results_.bytes_used += memory_used;
       record_results_.pixels_recorded +=
-          visible_content_rect.width() * visible_content_rect.height();
+          visible_layer_rect.width() * visible_layer_rect.height();
     }
     record_results_.total_best_time[mode_index] += min_time;
   }
 }
 
 void RasterizeAndRecordBenchmark::RunOnDisplayListLayer(
     PictureLayer* layer,
-    const gfx::Rect& visible_content_rect) {
+    const gfx::Rect& visible_layer_rect) {
   ContentLayerClient* painter = layer->client();
 
   DCHECK(host_ && host_->settings().use_display_lists);
 
   for (int mode_index = 0; mode_index < RecordingSource::RECORDING_MODE_COUNT;
        mode_index++) {
     ContentLayerClient::PaintingControlSetting painting_control =
         ContentLayerClient::PAINTING_BEHAVIOR_NORMAL;
     switch (static_cast<RecordingSource::RecordingMode>(mode_index)) {
       case RecordingSource::RECORD_NORMALLY:
@@ skipping 17 matching lines @@
 
     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(visible_content_rect,
+        display_list = painter->PaintContentsToDisplayList(visible_layer_rect,
                                                            painting_control);
+        display_list->CreateAndCacheSkPicture();
 
         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;
     }
 
     if (mode_index == RecordingSource::RECORD_NORMALLY) {
       record_results_.bytes_used += memory_used;
       record_results_.pixels_recorded +=
-          visible_content_rect.width() * visible_content_rect.height();
+          visible_layer_rect.width() * visible_layer_rect.height();
     }
     record_results_.total_best_time[mode_index] += min_time;
   }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
     : pixels_recorded(0), bytes_used(0) {
 }
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 
 }  // namespace cc