cc/playback/display_item_list.cc

   1 // Copyright 2014 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/playback/display_item_list.h"
   6
   7 #include <string>
   8
   9 #include "base/numerics/safe_conversions.h"
  10 #include "base/trace_event/trace_event.h"
  11 #include "base/trace_event/trace_event_argument.h"
  12 #include "cc/base/math_util.h"
  13 #include "cc/debug/picture_debug_util.h"
  14 #include "cc/debug/traced_display_item_list.h"
  15 #include "cc/debug/traced_picture.h"
  16 #include "cc/debug/traced_value.h"
  17 #include "cc/playback/display_item_list_settings.h"
  18 #include "cc/playback/largest_display_item.h"
  19 #include "third_party/skia/include/core/SkCanvas.h"
  20 #include "third_party/skia/include/core/SkPictureRecorder.h"
  21 #include "third_party/skia/include/utils/SkPictureUtils.h"
  22 #include "ui/gfx/skia_util.h"
  23
  24 namespace cc {
  25
  26 namespace {
  27
  28 // We don't perform per-layer solid color analysis when there are too many skia
  29 // operations.
  30 const int kOpCountThatIsOkToAnalyze = 10;
  31
  32 bool DisplayItemsTracingEnabled() {
  33   bool tracing_enabled;
  34   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
  35       TRACE_DISABLED_BY_DEFAULT("cc.debug.display_items"), &tracing_enabled);
  36   return tracing_enabled;
  37 }
  38
  39 const int kDefaultNumDisplayItemsToReserve = 100;
  40
  41 }  // namespace
  42
  43 scoped_refptr<DisplayItemList> DisplayItemList::Create(
  44     const gfx::Rect& layer_rect,
  45     const DisplayItemListSettings& settings) {
  46   return make_scoped_refptr(new DisplayItemList(
  47       layer_rect, settings,
  48       !settings.use_cached_picture || DisplayItemsTracingEnabled()));
  49 }
  50
  51 DisplayItemList::DisplayItemList(gfx::Rect layer_rect,
  52                                  const DisplayItemListSettings& settings,
  53                                  bool retain_individual_display_items)
  54     : items_(LargestDisplayItemSize(), kDefaultNumDisplayItemsToReserve),
  55       use_cached_picture_(settings.use_cached_picture),
  56       retain_individual_display_items_(retain_individual_display_items),
  57       layer_rect_(layer_rect),
  58       is_suitable_for_gpu_rasterization_(true),
  59       approximate_op_count_(0),
  60       picture_memory_usage_(0),
  61       external_memory_usage_(0) {
  62 #if DCHECK_IS_ON()
  63   needs_process_ = false;
  64 #endif
  65   if (use_cached_picture_) {
  66     SkRTreeFactory factory;
  67     recorder_.reset(new SkPictureRecorder());
  68     canvas_ = skia::SharePtr(recorder_->beginRecording(
  69         layer_rect_.width(), layer_rect_.height(), &factory));
  70     canvas_->translate(-layer_rect_.x(), -layer_rect_.y());
  71     canvas_->clipRect(gfx::RectToSkRect(layer_rect_));
  72   }
  73 }
  74
  75 DisplayItemList::~DisplayItemList() {
  76 }
  77
  78 void DisplayItemList::Raster(SkCanvas* canvas,
  79                              SkPicture::AbortCallback* callback,
  80                              const gfx::Rect& canvas_target_playback_rect,
  81                              float contents_scale) const {
  82   DCHECK(ProcessAppendedItemsCalled());
  83   if (!use_cached_picture_) {
  84     canvas->save();
  85     canvas->scale(contents_scale, contents_scale);
  86     for (auto* item : items_)
  87       item->Raster(canvas, canvas_target_playback_rect, callback);
  88     canvas->restore();
  89   } else {
  90     DCHECK(picture_);
  91
  92     canvas->save();
  93     canvas->scale(contents_scale, contents_scale);
  94     canvas->translate(layer_rect_.x(), layer_rect_.y());
  95     if (callback) {
  96       // If we have a callback, we need to call |draw()|, |drawPicture()|
  97       // doesn't take a callback.  This is used by |AnalysisCanvas| to early
  98       // out.
  99       picture_->playback(canvas, callback);
 100     } else {
 101       // Prefer to call |drawPicture()| on the canvas since it could place the
 102       // entire picture on the canvas instead of parsing the skia operations.
 103       canvas->drawPicture(picture_.get());
 104     }
 105     canvas->restore();
 106   }
 107 }
 108
 109 void DisplayItemList::ProcessAppendedItemsOnTheFly() {
 110   if (retain_individual_display_items_)
 111     return;
 112   if (items_.size() >= kDefaultNumDisplayItemsToReserve) {
 113     ProcessAppendedItems();
 114     // This function exists to keep the |items_| from growing indefinitely if
 115     // we're not going to store them anyway. So the items better be deleted
 116     // after |items_| grows too large and we process it.
 117     DCHECK(items_.empty());
 118   }
 119 }
 120
 121 void DisplayItemList::ProcessAppendedItems() {
 122 #if DCHECK_IS_ON()
 123   needs_process_ = false;
 124 #endif
 125   for (const DisplayItem* item : items_) {
 126     if (use_cached_picture_) {
 127       // When using a cached picture we will calculate gpu suitability on the
 128       // entire cached picture instead of the items. This is more permissive
 129       // since none of the items might individually trigger a veto even though
 130       // they collectively have enough "bad" operations that a corresponding
 131       // Picture would get vetoed. See crbug.com/513016.
 132       DCHECK(canvas_);
 133       approximate_op_count_ += item->approximate_op_count();
 134       item->Raster(canvas_.get(), gfx::Rect(), nullptr);
 135     } else {
 136       is_suitable_for_gpu_rasterization_ &=
 137           item->is_suitable_for_gpu_rasterization();
 138       approximate_op_count_ += item->approximate_op_count();
 139     }
 140
 141     if (retain_individual_display_items_) {
 142       // Warning: this double-counts SkPicture data if use_cached_picture_ is
 143       // also true.
 144       external_memory_usage_ += item->external_memory_usage();
 145     }
 146   }
 147
 148   if (!retain_individual_display_items_)
 149     items_.clear();
 150 }
 151
 152 void DisplayItemList::RasterIntoCanvas(const DisplayItem& item) {
 153   DCHECK(canvas_);
 154   DCHECK(!retain_individual_display_items_);
 155   approximate_op_count_ += item.approximate_op_count();
 156
 157   item.Raster(canvas_.get(), gfx::Rect(), nullptr);
 158 }
 159
 160 bool DisplayItemList::RetainsIndividualDisplayItems() const {
 161   return retain_individual_display_items_;
 162 }
 163
 164 void DisplayItemList::RemoveLast() {
 165   // We cannot remove the last item if it has been squashed into a picture.
 166   // The last item should not have been handled by ProcessAppendedItems, so we
 167   // don't need to remove it from approximate_op_count_, etc.
 168   DCHECK(retain_individual_display_items_);
 169   DCHECK(!use_cached_picture_);
 170   items_.RemoveLast();
 171 }
 172
 173 void DisplayItemList::Finalize() {
 174   ProcessAppendedItems();
 175
 176   if (use_cached_picture_) {
 177     // Convert to an SkPicture for faster rasterization.
 178     DCHECK(use_cached_picture_);
 179     DCHECK(!picture_);
 180     picture_ = skia::AdoptRef(recorder_->endRecordingAsPicture());
 181     DCHECK(picture_);
 182     picture_memory_usage_ =
 183         SkPictureUtils::ApproximateBytesUsed(picture_.get());
 184     recorder_.reset();
 185     canvas_.clear();
 186     is_suitable_for_gpu_rasterization_ =
 187         picture_->suitableForGpuRasterization(nullptr);
 188   }
 189 }
 190
 191 bool DisplayItemList::IsSuitableForGpuRasterization() const {
 192   DCHECK(ProcessAppendedItemsCalled());
 193   return is_suitable_for_gpu_rasterization_;
 194 }
 195
 196 int DisplayItemList::ApproximateOpCount() const {
 197   DCHECK(ProcessAppendedItemsCalled());
 198   return approximate_op_count_;
 199 }
 200
 201 size_t DisplayItemList::ApproximateMemoryUsage() const {
 202   DCHECK(ProcessAppendedItemsCalled());
 203   // We double-count in this case. Produce zero to avoid being misleading.
 204   if (use_cached_picture_ && retain_individual_display_items_)
 205     return 0;
 206
 207   DCHECK_IMPLIES(use_cached_picture_, picture_);
 208
 209   size_t memory_usage = sizeof(*this);
 210
 211   // Memory outside this class due to |items_|.
 212   memory_usage += items_.GetCapacityInBytes() + external_memory_usage_;
 213
 214   // Memory outside this class due to |picture|.
 215   memory_usage += picture_memory_usage_;
 216
 217   // TODO(jbroman): Does anything else owned by this class substantially
 218   // contribute to memory usage?
 219
 220   return memory_usage;
 221 }
 222
 223 bool DisplayItemList::ShouldBeAnalyzedForSolidColor() const {
 224   return ApproximateOpCount() <= kOpCountThatIsOkToAnalyze;
 225 }
 226
 227 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 228 DisplayItemList::AsValue(bool include_items) const {
 229   DCHECK(ProcessAppendedItemsCalled());
 230   scoped_refptr<base::trace_event::TracedValue> state =
 231       new base::trace_event::TracedValue();
 232
 233   state->BeginDictionary("params");
 234   if (include_items) {
 235     state->BeginArray("items");
 236     for (const DisplayItem* item : items_) {
 237       item->AsValueInto(state.get());
 238     }
 239     state->EndArray();  // "items".
 240   }
 241   state->SetValue("layer_rect", MathUtil::AsValue(layer_rect_));
 242   state->EndDictionary();  // "params".
 243
 244   if (!layer_rect_.IsEmpty()) {
 245     SkPictureRecorder recorder;
 246     SkCanvas* canvas =
 247         recorder.beginRecording(layer_rect_.width(), layer_rect_.height());
 248     canvas->translate(-layer_rect_.x(), -layer_rect_.y());
 249     canvas->clipRect(gfx::RectToSkRect(layer_rect_));
 250     Raster(canvas, NULL, gfx::Rect(), 1.f);
 251     skia::RefPtr<SkPicture> picture =
 252         skia::AdoptRef(recorder.endRecordingAsPicture());
 253
 254     std::string b64_picture;
 255     PictureDebugUtil::SerializeAsBase64(picture.get(), &b64_picture);
 256     state->SetString("skp64", b64_picture);
 257   }
 258
 259   return state;
 260 }
 261
 262 void DisplayItemList::EmitTraceSnapshot() const {
 263   DCHECK(ProcessAppendedItemsCalled());
 264   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
 265       TRACE_DISABLED_BY_DEFAULT("cc.debug.display_items") ","
 266       TRACE_DISABLED_BY_DEFAULT("cc.debug.picture") ","
 267       TRACE_DISABLED_BY_DEFAULT("devtools.timeline.picture"),
 268       "cc::DisplayItemList", this,
 269       TracedDisplayItemList::AsTraceableDisplayItemList(this,
 270           DisplayItemsTracingEnabled()));
 271 }
 272
 273 void DisplayItemList::GatherDiscardableImages(const gfx::Size& grid_cell_size) {
 274   DCHECK(ProcessAppendedItemsCalled());
 275   // This should be only called once, and only after CreateAndCacheSkPicture.
 276   DCHECK(picture_);
 277   DCHECK(!images_);
 278   images_ = make_scoped_ptr(new DiscardableImageMap(grid_cell_size));
 279   if (!picture_->willPlayBackBitmaps())
 280     return;
 281
 282   images_->GatherImagesFromPicture(picture_.get(), layer_rect_);
 283 }
 284
 285 }  // namespace cc