cc/debug/rasterize_and_record_benchmark_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/debug/rasterize_and_record_benchmark_impl.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9
  10 #include "base/basictypes.h"
  11 #include "base/values.h"
  12 #include "cc/layers/layer_impl.h"
  13 #include "cc/layers/picture_layer_impl.h"
  14 #include "cc/trees/layer_tree_host_common.h"
  15 #include "cc/trees/layer_tree_host_impl.h"
  16 #include "ui/gfx/rect.h"
  17
  18 namespace cc {
  19
  20 namespace {
  21
  22 const int kDefaultRasterizeRepeatCount = 100;
  23
  24 base::TimeTicks Now() {
  25   return base::TimeTicks::IsThreadNowSupported()
  26              ? base::TimeTicks::ThreadNow()
  27              : base::TimeTicks::HighResNow();
  28 }
  29
  30 }  // namespace
  31
  32 RasterizeAndRecordBenchmarkImpl::RasterizeAndRecordBenchmarkImpl(
  33     scoped_refptr<base::MessageLoopProxy> origin_loop,
  34     base::Value* value,
  35     const MicroBenchmarkImpl::DoneCallback& callback)
  36     : MicroBenchmarkImpl(callback, origin_loop),
  37       rasterize_repeat_count_(kDefaultRasterizeRepeatCount) {
  38   base::DictionaryValue* settings = NULL;
  39   value->GetAsDictionary(&settings);
  40   if (!settings)
  41     return;
  42
  43   if (settings->HasKey("rasterize_repeat_count"))
  44     settings->GetInteger("rasterize_repeat_count", &rasterize_repeat_count_);
  45 }
  46
  47 RasterizeAndRecordBenchmarkImpl::~RasterizeAndRecordBenchmarkImpl() {}
  48
  49 void RasterizeAndRecordBenchmarkImpl::DidCompleteCommit(
  50     LayerTreeHostImpl* host) {
  51   LayerTreeHostCommon::CallFunctionForSubtree(
  52       host->RootLayer(),
  53       base::Bind(&RasterizeAndRecordBenchmarkImpl::Run,
  54                  base::Unretained(this)));
  55
  56   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
  57   result->SetDouble("rasterize_time_ms",
  58                     rasterize_results_.total_best_time.InMillisecondsF());
  59   result->SetInteger("pixels_rasterized", rasterize_results_.pixels_rasterized);
  60   result->SetInteger("pixels_rasterized_with_non_solid_color",
  61                      rasterize_results_.pixels_rasterized_with_non_solid_color);
  62   result->SetInteger("pixels_rasterized_as_opaque",
  63                      rasterize_results_.pixels_rasterized_as_opaque);
  64   result->SetInteger("total_layers", rasterize_results_.total_layers);
  65   result->SetInteger("total_picture_layers",
  66                      rasterize_results_.total_picture_layers);
  67   result->SetInteger("total_picture_layers_with_no_content",
  68                      rasterize_results_.total_picture_layers_with_no_content);
  69   result->SetInteger("total_picture_layers_off_screen",
  70                      rasterize_results_.total_picture_layers_off_screen);
  71
  72   NotifyDone(result.PassAs<base::Value>());
  73 }
  74
  75 void RasterizeAndRecordBenchmarkImpl::Run(LayerImpl* layer) {
  76   rasterize_results_.total_layers++;
  77   layer->RunMicroBenchmark(this);
  78 }
  79
  80 void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
  81   rasterize_results_.total_picture_layers++;
  82   if (!layer->DrawsContent()) {
  83     rasterize_results_.total_picture_layers_with_no_content++;
  84     return;
  85   }
  86   if (layer->visible_content_rect().IsEmpty()) {
  87     rasterize_results_.total_picture_layers_off_screen++;
  88     return;
  89   }
  90
  91   PictureLayerTilingSet tiling_set(layer, layer->content_bounds());
  92
  93   PictureLayerTiling* tiling = tiling_set.AddTiling(layer->contents_scale_x());
  94   tiling->CreateAllTilesForTesting();
  95   for (PictureLayerTiling::CoverageIterator it(
  96            tiling, layer->contents_scale_x(), layer->visible_content_rect());
  97        it;
  98        ++it) {
  99     DCHECK(*it);
 100
 101     PicturePileImpl* picture_pile = (*it)->picture_pile();
 102     gfx::Rect content_rect = (*it)->content_rect();
 103     float contents_scale = (*it)->contents_scale();
 104
 105     int tile_size = content_rect.width() * content_rect.height();
 106
 107     base::TimeDelta min_time = base::TimeDelta::Max();
 108
 109     bool is_solid_color = false;
 110     for (int i = 0; i < rasterize_repeat_count_; ++i) {
 111       SkBitmap bitmap;
 112       bitmap.allocPixels(SkImageInfo::MakeN32Premul(content_rect.width(),
 113                                                     content_rect.height()));
 114       SkCanvas canvas(bitmap);
 115       PicturePileImpl::Analysis analysis;
 116
 117       base::TimeTicks start = Now();
 118       picture_pile->AnalyzeInRect(
 119           content_rect, contents_scale, &analysis, NULL);
 120       picture_pile->RasterToBitmap(&canvas, content_rect, contents_scale, NULL);
 121       base::TimeTicks end = Now();
 122       base::TimeDelta duration = end - start;
 123       if (duration < min_time)
 124         min_time = duration;
 125
 126       is_solid_color = analysis.is_solid_color;
 127     }
 128
 129     if (layer->contents_opaque())
 130       rasterize_results_.pixels_rasterized_as_opaque += tile_size;
 131
 132     if (!is_solid_color) {
 133       rasterize_results_.pixels_rasterized_with_non_solid_color += tile_size;
 134     }
 135
 136     rasterize_results_.pixels_rasterized += tile_size;
 137     rasterize_results_.total_best_time += min_time;
 138   }
 139 }
 140
 141 RasterizeAndRecordBenchmarkImpl::RasterizeResults::RasterizeResults()
 142     : pixels_rasterized(0),
 143       pixels_rasterized_with_non_solid_color(0),
 144       pixels_rasterized_as_opaque(0),
 145       total_layers(0),
 146       total_picture_layers(0),
 147       total_picture_layers_with_no_content(0),
 148       total_picture_layers_off_screen(0) {}
 149
 150 RasterizeAndRecordBenchmarkImpl::RasterizeResults::~RasterizeResults() {}
 151
 152 }  // namespace cc