| // Copyright 2014 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/playback/display_item_list.h" |
| |
| #include <string> |
| |
| #include "base/numerics/safe_conversions.h" |
| #include "base/trace_event/trace_event.h" |
| #include "base/trace_event/trace_event_argument.h" |
| #include "cc/base/math_util.h" |
| #include "cc/debug/picture_debug_util.h" |
| #include "cc/debug/traced_display_item_list.h" |
| #include "cc/debug/traced_picture.h" |
| #include "cc/debug/traced_value.h" |
| #include "cc/playback/display_item_list_settings.h" |
| #include "cc/playback/largest_display_item.h" |
| #include "third_party/skia/include/core/SkCanvas.h" |
| #include "third_party/skia/include/core/SkPictureRecorder.h" |
| #include "third_party/skia/include/utils/SkPictureUtils.h" |
| #include "ui/gfx/skia_util.h" |
| |
| namespace cc { |
| |
| namespace { |
| |
| bool DisplayItemsTracingEnabled() { |
| bool tracing_enabled; |
| TRACE_EVENT_CATEGORY_GROUP_ENABLED( |
| TRACE_DISABLED_BY_DEFAULT("cc.debug.display_items"), &tracing_enabled); |
| return tracing_enabled; |
| } |
| |
| const int kDefaultNumDisplayItemsToReserve = 100; |
| |
| } // namespace |
| |
| DisplayItemList::DisplayItemList(gfx::Rect layer_rect, |
| const DisplayItemListSettings& settings, |
| bool retain_individual_display_items) |
| : items_(LargestDisplayItemSize(), |
| settings.max_sidecar_size, |
| kDefaultNumDisplayItemsToReserve, |
| settings.sidecar_destroyer), |
| use_cached_picture_(settings.use_cached_picture), |
| retain_individual_display_items_(retain_individual_display_items), |
| layer_rect_(layer_rect), |
| is_suitable_for_gpu_rasterization_(true), |
| approximate_op_count_(0), |
| picture_memory_usage_(0), |
| external_memory_usage_(0) { |
| #if DCHECK_IS_ON() |
| needs_process_ = false; |
| #endif |
| if (use_cached_picture_) { |
| SkRTreeFactory factory; |
| recorder_.reset(new SkPictureRecorder()); |
| canvas_ = skia::SharePtr(recorder_->beginRecording( |
| layer_rect_.width(), layer_rect_.height(), &factory)); |
| canvas_->translate(-layer_rect_.x(), -layer_rect_.y()); |
| canvas_->clipRect(gfx::RectToSkRect(layer_rect_)); |
| } |
| } |
| |
| DisplayItemList::DisplayItemList(gfx::Rect layer_rect, |
| const DisplayItemListSettings& settings) |
| : DisplayItemList( |
| layer_rect, |
| settings, |
| !settings.use_cached_picture || DisplayItemsTracingEnabled()) { |
| } |
| |
| scoped_refptr<DisplayItemList> DisplayItemList::CreateWithoutCachedPicture( |
| const DisplayItemListSettings& settings) { |
| DCHECK(!settings.use_cached_picture); |
| return Create(gfx::Rect(), settings); |
| } |
| |
| scoped_refptr<DisplayItemList> DisplayItemList::Create( |
| gfx::Rect layer_rect, |
| bool use_cached_picture) { |
| DisplayItemListSettings settings; |
| settings.use_cached_picture = use_cached_picture; |
| return Create(layer_rect, settings); |
| } |
| |
| scoped_refptr<DisplayItemList> DisplayItemList::Create( |
| gfx::Rect layer_rect, |
| const DisplayItemListSettings& settings) { |
| return make_scoped_refptr(new DisplayItemList(layer_rect, settings)); |
| } |
| |
| DisplayItemList::~DisplayItemList() { |
| } |
| |
| void DisplayItemList::Raster(SkCanvas* canvas, |
| SkPicture::AbortCallback* callback, |
| const gfx::Rect& canvas_target_playback_rect, |
| float contents_scale) const { |
| DCHECK(ProcessAppendedItemsCalled()); |
| if (!use_cached_picture_) { |
| canvas->save(); |
| canvas->scale(contents_scale, contents_scale); |
| for (auto* item : items_) |
| item->Raster(canvas, canvas_target_playback_rect, callback); |
| canvas->restore(); |
| } else { |
| DCHECK(picture_); |
| |
| canvas->save(); |
| canvas->scale(contents_scale, contents_scale); |
| canvas->translate(layer_rect_.x(), layer_rect_.y()); |
| if (callback) { |
| // If we have a callback, we need to call |draw()|, |drawPicture()| |
| // doesn't take a callback. This is used by |AnalysisCanvas| to early |
| // out. |
| picture_->playback(canvas, callback); |
| } else { |
| // Prefer to call |drawPicture()| on the canvas since it could place the |
| // entire picture on the canvas instead of parsing the skia operations. |
| canvas->drawPicture(picture_.get()); |
| } |
| canvas->restore(); |
| } |
| } |
| |
| void DisplayItemList::ProcessAppendedItemsOnTheFly() { |
| if (retain_individual_display_items_) |
| return; |
| if (items_.size() >= kDefaultNumDisplayItemsToReserve) { |
| ProcessAppendedItems(); |
| // This function exists to keep the |items_| from growing indefinitely if |
| // we're not going to store them anyway. So the items better be deleted |
| // after |items_| grows too large and we process it. |
| DCHECK(items_.empty()); |
| } |
| } |
| |
| void DisplayItemList::ProcessAppendedItems() { |
| #if DCHECK_IS_ON() |
| needs_process_ = false; |
| #endif |
| for (const DisplayItem* item : items_) { |
| is_suitable_for_gpu_rasterization_ &= |
| item->is_suitable_for_gpu_rasterization(); |
| approximate_op_count_ += item->approximate_op_count(); |
| |
| if (use_cached_picture_) { |
| DCHECK(canvas_); |
| item->Raster(canvas_.get(), gfx::Rect(), NULL); |
| } |
| |
| if (retain_individual_display_items_) { |
| // Warning: this double-counts SkPicture data if use_cached_picture_ is |
| // also true. |
| external_memory_usage_ += item->external_memory_usage(); |
| } |
| } |
| |
| if (!retain_individual_display_items_) |
| items_.clear(); |
| } |
| |
| void DisplayItemList::RasterIntoCanvas(const DisplayItem& item) { |
| DCHECK(canvas_); |
| DCHECK(!retain_individual_display_items_); |
| is_suitable_for_gpu_rasterization_ &= |
| item.is_suitable_for_gpu_rasterization(); |
| approximate_op_count_ += item.approximate_op_count(); |
| |
| item.Raster(canvas_.get(), gfx::Rect(), NULL); |
| } |
| |
| bool DisplayItemList::RetainsIndividualDisplayItems() const { |
| return retain_individual_display_items_; |
| } |
| |
| void DisplayItemList::RemoveLast() { |
| // We cannot remove the last item if it has been squashed into a picture. |
| // The last item should not have been handled by ProcessAppendedItems, so we |
| // don't need to remove it from approximate_op_count_, etc. |
| DCHECK(retain_individual_display_items_); |
| DCHECK(!use_cached_picture_); |
| items_.RemoveLast(); |
| } |
| |
| void DisplayItemList::Finalize() { |
| ProcessAppendedItems(); |
| |
| if (use_cached_picture_) { |
| // Convert to an SkPicture for faster rasterization. |
| DCHECK(use_cached_picture_); |
| DCHECK(!picture_); |
| picture_ = skia::AdoptRef(recorder_->endRecordingAsPicture()); |
| DCHECK(picture_); |
| picture_memory_usage_ = |
| SkPictureUtils::ApproximateBytesUsed(picture_.get()); |
| recorder_.reset(); |
| canvas_.clear(); |
| } |
| } |
| |
| bool DisplayItemList::IsSuitableForGpuRasterization() const { |
| DCHECK(ProcessAppendedItemsCalled()); |
| // This is more permissive than Picture's implementation, since none of the |
| // items might individually trigger a veto even though they collectively have |
| // enough "bad" operations that a corresponding Picture would get vetoed. |
| return is_suitable_for_gpu_rasterization_; |
| } |
| |
| int DisplayItemList::ApproximateOpCount() const { |
| DCHECK(ProcessAppendedItemsCalled()); |
| return approximate_op_count_; |
| } |
| |
| size_t DisplayItemList::ApproximateMemoryUsage() const { |
| DCHECK(ProcessAppendedItemsCalled()); |
| // We double-count in this case. Produce zero to avoid being misleading. |
| if (use_cached_picture_ && retain_individual_display_items_) |
| return 0; |
| |
| DCHECK_IMPLIES(use_cached_picture_, picture_); |
| |
| size_t memory_usage = sizeof(*this); |
| |
| // Memory outside this class due to |items_|. |
| memory_usage += items_.GetCapacityInBytes() + external_memory_usage_; |
| |
| // Memory outside this class due to |picture|. |
| memory_usage += picture_memory_usage_; |
| |
| // TODO(jbroman): Does anything else owned by this class substantially |
| // contribute to memory usage? |
| |
| return memory_usage; |
| } |
| |
| scoped_refptr<base::trace_event::ConvertableToTraceFormat> |
| DisplayItemList::AsValue(bool include_items) const { |
| DCHECK(ProcessAppendedItemsCalled()); |
| scoped_refptr<base::trace_event::TracedValue> state = |
| new base::trace_event::TracedValue(); |
| |
| if (include_items) { |
| state->BeginArray("params.items"); |
| for (const DisplayItem* item : items_) { |
| item->AsValueInto(state.get()); |
| } |
| state->EndArray(); |
| } |
| |
| state->SetValue("params.layer_rect", MathUtil::AsValue(layer_rect_)); |
| |
| if (!layer_rect_.IsEmpty()) { |
| SkPictureRecorder recorder; |
| SkCanvas* canvas = |
| recorder.beginRecording(layer_rect_.width(), layer_rect_.height()); |
| canvas->translate(-layer_rect_.x(), -layer_rect_.y()); |
| canvas->clipRect(gfx::RectToSkRect(layer_rect_)); |
| Raster(canvas, NULL, gfx::Rect(), 1.f); |
| skia::RefPtr<SkPicture> picture = |
| skia::AdoptRef(recorder.endRecordingAsPicture()); |
| |
| std::string b64_picture; |
| PictureDebugUtil::SerializeAsBase64(picture.get(), &b64_picture); |
| state->SetString("skp64", b64_picture); |
| } |
| |
| return state; |
| } |
| |
| void DisplayItemList::EmitTraceSnapshot() const { |
| DCHECK(ProcessAppendedItemsCalled()); |
| TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID( |
| TRACE_DISABLED_BY_DEFAULT("cc.debug.display_items") "," |
| TRACE_DISABLED_BY_DEFAULT("cc.debug.picture") "," |
| TRACE_DISABLED_BY_DEFAULT("devtools.timeline.picture"), |
| "cc::DisplayItemList", this, |
| TracedDisplayItemList::AsTraceableDisplayItemList(this, |
| DisplayItemsTracingEnabled())); |
| } |
| |
| void DisplayItemList::GatherPixelRefs(const gfx::Size& grid_cell_size) { |
| DCHECK(ProcessAppendedItemsCalled()); |
| // This should be only called once, and only after CreateAndCacheSkPicture. |
| DCHECK(picture_); |
| DCHECK(!pixel_refs_); |
| pixel_refs_ = make_scoped_ptr(new PixelRefMap(grid_cell_size)); |
| if (!picture_->willPlayBackBitmaps()) |
| return; |
| |
| pixel_refs_->GatherPixelRefsFromPicture(picture_.get()); |
| } |
| |
| void* DisplayItemList::GetSidecar(DisplayItem* display_item) { |
| return items_.GetSidecar(display_item); |
| } |
| |
| } // namespace cc |