diff options
32 files changed, 496 insertions, 553 deletions
diff --git a/cc/blink/web_display_item_list_impl.cc b/cc/blink/web_display_item_list_impl.cc index b030e93..9859d1c 100644 --- a/cc/blink/web_display_item_list_impl.cc +++ b/cc/blink/web_display_item_list_impl.cc @@ -50,13 +50,11 @@ void WebDisplayItemListImpl::appendDrawingItem( const blink::WebRect& visual_rect, const SkPicture* picture) { if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = - display_item_list_->CreateAndAppendItem<cc::DrawingDisplayItem>( - visual_rect); - item->SetNew(skia::SharePtr(const_cast<SkPicture*>(picture))); + display_item_list_->CreateAndAppendItem<cc::DrawingDisplayItem>( + visual_rect, skia::SharePtr(const_cast<SkPicture*>(picture))); } else { - cc::DrawingDisplayItem item; - item.SetNew(skia::SharePtr(const_cast<SkPicture*>(picture))); + cc::DrawingDisplayItem item( + skia::SharePtr(const_cast<SkPicture*>(picture))); display_item_list_->RasterIntoCanvas(item); } } @@ -70,12 +68,10 @@ void WebDisplayItemListImpl::appendClipItem( rounded_rects.push_back(rounded_clip_rects[i]); } if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = display_item_list_->CreateAndAppendItem<cc::ClipDisplayItem>( - visual_rect); - item->SetNew(clip_rect, rounded_rects); + display_item_list_->CreateAndAppendItem<cc::ClipDisplayItem>( + visual_rect, clip_rect, rounded_rects); } else { - cc::ClipDisplayItem item; - item.SetNew(clip_rect, rounded_rects); + cc::ClipDisplayItem item(clip_rect, rounded_rects); display_item_list_->RasterIntoCanvas(item); } } @@ -96,13 +92,10 @@ void WebDisplayItemListImpl::appendClipPathItem( SkRegion::Op clip_op, bool antialias) { if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = - display_item_list_->CreateAndAppendItem<cc::ClipPathDisplayItem>( - visual_rect); - item->SetNew(clip_path, clip_op, antialias); + display_item_list_->CreateAndAppendItem<cc::ClipPathDisplayItem>( + visual_rect, clip_path, clip_op, antialias); } else { - cc::ClipPathDisplayItem item; - item.SetNew(clip_path, clip_op, antialias); + cc::ClipPathDisplayItem item(clip_path, clip_op, antialias); display_item_list_->RasterIntoCanvas(item); } } @@ -121,13 +114,10 @@ void WebDisplayItemListImpl::appendFloatClipItem( const blink::WebRect& visual_rect, const blink::WebFloatRect& clip_rect) { if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = - display_item_list_->CreateAndAppendItem<cc::FloatClipDisplayItem>( - visual_rect); - item->SetNew(clip_rect); + display_item_list_->CreateAndAppendItem<cc::FloatClipDisplayItem>( + visual_rect, clip_rect); } else { - cc::FloatClipDisplayItem item; - item.SetNew(clip_rect); + cc::FloatClipDisplayItem item(clip_rect); display_item_list_->RasterIntoCanvas(item); } } @@ -149,13 +139,10 @@ void WebDisplayItemListImpl::appendTransformItem( transform.matrix() = matrix; if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = - display_item_list_->CreateAndAppendItem<cc::TransformDisplayItem>( - visual_rect); - item->SetNew(transform); + display_item_list_->CreateAndAppendItem<cc::TransformDisplayItem>( + visual_rect, transform); } else { - cc::TransformDisplayItem item; - item.SetNew(transform); + cc::TransformDisplayItem item(transform); display_item_list_->RasterIntoCanvas(item); } } @@ -182,15 +169,13 @@ void WebDisplayItemListImpl::appendCompositingItem( // value, but that breaks slimming paint reftests. if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = - display_item_list_->CreateAndAppendItem<cc::CompositingDisplayItem>( - visual_rect); - item->SetNew(static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), - xfermode, bounds, skia::SharePtr(color_filter)); + display_item_list_->CreateAndAppendItem<cc::CompositingDisplayItem>( + visual_rect, static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), + xfermode, bounds, skia::SharePtr(color_filter)); } else { - cc::CompositingDisplayItem item; - item.SetNew(static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), - xfermode, bounds, skia::SharePtr(color_filter)); + cc::CompositingDisplayItem item( + static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), xfermode, + bounds, skia::SharePtr(color_filter)); display_item_list_->RasterIntoCanvas(item); } } @@ -213,12 +198,10 @@ void WebDisplayItemListImpl::appendFilterItem( static_cast<const WebFilterOperationsImpl&>(filters); if (display_item_list_->RetainsIndividualDisplayItems()) { - auto* item = display_item_list_->CreateAndAppendItem<cc::FilterDisplayItem>( - visual_rect); - item->SetNew(filters_impl.AsFilterOperations(), bounds); + display_item_list_->CreateAndAppendItem<cc::FilterDisplayItem>( + visual_rect, filters_impl.AsFilterOperations(), bounds); } else { - cc::FilterDisplayItem item; - item.SetNew(filters_impl.AsFilterOperations(), bounds); + cc::FilterDisplayItem item(filters_impl.AsFilterOperations(), bounds); display_item_list_->RasterIntoCanvas(item); } } diff --git a/cc/layers/picture_image_layer.cc b/cc/layers/picture_image_layer.cc index cde9ccd..0ca203e 100644 --- a/cc/layers/picture_image_layer.cc +++ b/cc/layers/picture_image_layer.cc @@ -83,9 +83,8 @@ scoped_refptr<DisplayItemList> PictureImageLayer::PaintContentsToDisplayList( skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item = - display_list->CreateAndAppendItem<DrawingDisplayItem>(PaintableRegion()); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>(PaintableRegion(), + std::move(picture)); display_list->Finalize(); return display_list; diff --git a/cc/playback/clip_display_item.cc b/cc/playback/clip_display_item.cc index d89566c..96a2df8 100644 --- a/cc/playback/clip_display_item.cc +++ b/cc/playback/clip_display_item.cc @@ -17,24 +17,33 @@ namespace cc { -ClipDisplayItem::ClipDisplayItem() { +ClipDisplayItem::ClipDisplayItem( + const gfx::Rect& clip_rect, + const std::vector<SkRRect>& rounded_clip_rects) { + SetNew(clip_rect, rounded_clip_rects); } -ClipDisplayItem::~ClipDisplayItem() { +ClipDisplayItem::ClipDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_Clip, proto.type()); + + const proto::ClipDisplayItem& details = proto.clip_item(); + gfx::Rect clip_rect = ProtoToRect(details.clip_rect()); + std::vector<SkRRect> rounded_clip_rects; + rounded_clip_rects.reserve(details.rounded_rects_size()); + for (int i = 0; i < details.rounded_rects_size(); i++) { + rounded_clip_rects.push_back(ProtoToSkRRect(details.rounded_rects(i))); + } + SetNew(clip_rect, rounded_clip_rects); } -void ClipDisplayItem::SetNew(gfx::Rect clip_rect, +void ClipDisplayItem::SetNew(const gfx::Rect& clip_rect, const std::vector<SkRRect>& rounded_clip_rects) { clip_rect_ = clip_rect; rounded_clip_rects_ = rounded_clip_rects; - - size_t external_memory_usage = - rounded_clip_rects_.capacity() * sizeof(rounded_clip_rects_[0]); - - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 1 /* op_count */, - external_memory_usage); } +ClipDisplayItem::~ClipDisplayItem() {} + void ClipDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_Clip); @@ -46,19 +55,6 @@ void ClipDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { } } -void ClipDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_Clip, proto.type()); - - const proto::ClipDisplayItem& details = proto.clip_item(); - gfx::Rect clip_rect = ProtoToRect(details.clip_rect()); - std::vector<SkRRect> rounded_clip_rects; - rounded_clip_rects.reserve(details.rounded_rects_size()); - for (int i = 0; i < details.rounded_rects_size(); i++) { - rounded_clip_rects.push_back(ProtoToSkRRect(details.rounded_rects(i))); - } - SetNew(clip_rect, rounded_clip_rects); -} - void ClipDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -104,9 +100,14 @@ void ClipDisplayItem::AsValueInto(const gfx::Rect& visual_rect, array->AppendString(value); } -EndClipDisplayItem::EndClipDisplayItem() { - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 0 /* op_count */, - 0 /* external_memory_usage */); +size_t ClipDisplayItem::ExternalMemoryUsage() const { + return rounded_clip_rects_.capacity() * sizeof(rounded_clip_rects_[0]); +} + +EndClipDisplayItem::EndClipDisplayItem() {} + +EndClipDisplayItem::EndClipDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_EndClip, proto.type()); } EndClipDisplayItem::~EndClipDisplayItem() { @@ -116,10 +117,6 @@ void EndClipDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_EndClip); } -void EndClipDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_EndClip, proto.type()); -} - void EndClipDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -133,4 +130,8 @@ void EndClipDisplayItem::AsValueInto( visual_rect.ToString().c_str())); } +size_t EndClipDisplayItem::ExternalMemoryUsage() const { + return 0; +} + } // namespace cc diff --git a/cc/playback/clip_display_item.h b/cc/playback/clip_display_item.h index c66e467..5140213 100644 --- a/cc/playback/clip_display_item.h +++ b/cc/playback/clip_display_item.h @@ -19,21 +19,26 @@ namespace cc { class CC_EXPORT ClipDisplayItem : public DisplayItem { public: - ClipDisplayItem(); + ClipDisplayItem(const gfx::Rect& clip_rect, + const std::vector<SkRRect>& rounded_clip_rects); + explicit ClipDisplayItem(const proto::DisplayItem& proto); ~ClipDisplayItem() override; - void SetNew(gfx::Rect clip_rect, - const std::vector<SkRRect>& rounded_clip_rects); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 1; } + bool IsSuitableForGpuRasterization() const { return true; } private: + void SetNew(const gfx::Rect& clip_rect, + const std::vector<SkRRect>& rounded_clip_rects); + gfx::Rect clip_rect_; std::vector<SkRRect> rounded_clip_rects_; }; @@ -41,15 +46,19 @@ class CC_EXPORT ClipDisplayItem : public DisplayItem { class CC_EXPORT EndClipDisplayItem : public DisplayItem { public: EndClipDisplayItem(); + explicit EndClipDisplayItem(const proto::DisplayItem& proto); ~EndClipDisplayItem() override; void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 0; } + bool IsSuitableForGpuRasterization() const { return true; } }; } // namespace cc diff --git a/cc/playback/clip_path_display_item.cc b/cc/playback/clip_path_display_item.cc index 2168ee1..5b9b3f2 100644 --- a/cc/playback/clip_path_display_item.cc +++ b/cc/playback/clip_path_display_item.cc @@ -12,7 +12,27 @@ namespace cc { -ClipPathDisplayItem::ClipPathDisplayItem() { +ClipPathDisplayItem::ClipPathDisplayItem(const SkPath& clip_path, + SkRegion::Op clip_op, + bool antialias) { + SetNew(clip_path, clip_op, antialias); +} + +ClipPathDisplayItem::ClipPathDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_ClipPath, proto.type()); + + const proto::ClipPathDisplayItem& details = proto.clip_path_item(); + SkRegion::Op clip_op = SkRegionOpFromProto(details.clip_op()); + bool antialias = details.antialias(); + + SkPath clip_path; + if (details.has_clip_path()) { + size_t bytes_read = clip_path.readFromMemory(details.clip_path().data(), + details.clip_path().size()); + DCHECK_EQ(details.clip_path().size(), bytes_read); + } + + SetNew(clip_path, clip_op, antialias); } ClipPathDisplayItem::~ClipPathDisplayItem() { @@ -24,11 +44,6 @@ void ClipPathDisplayItem::SetNew(const SkPath& clip_path, clip_path_ = clip_path; clip_op_ = clip_op; antialias_ = antialias; - - // The size of SkPath's external storage is not currently accounted for (and - // may well be shared anyway). - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 1 /* op_count */, - 0 /* external_memory_usage */); } void ClipPathDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { @@ -47,23 +62,6 @@ void ClipPathDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { } } -void ClipPathDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_ClipPath, proto.type()); - - const proto::ClipPathDisplayItem& details = proto.clip_path_item(); - SkRegion::Op clip_op = SkRegionOpFromProto(details.clip_op()); - bool antialias = details.antialias(); - - SkPath clip_path; - if (details.has_clip_path()) { - size_t bytes_read = clip_path.readFromMemory(details.clip_path().data(), - details.clip_path().size()); - DCHECK_EQ(details.clip_path().size(), bytes_read); - } - - SetNew(clip_path, clip_op, antialias); -} - void ClipPathDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -79,9 +77,17 @@ void ClipPathDisplayItem::AsValueInto( clip_path_.countPoints(), visual_rect.ToString().c_str())); } -EndClipPathDisplayItem::EndClipPathDisplayItem() { - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 0 /* op_count */, - 0 /* external_memory_usage */); +size_t ClipPathDisplayItem::ExternalMemoryUsage() const { + // The size of SkPath's external storage is not currently accounted for (and + // may well be shared anyway). + return 0; +} + +EndClipPathDisplayItem::EndClipPathDisplayItem() {} + +EndClipPathDisplayItem::EndClipPathDisplayItem( + const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_EndClipPath, proto.type()); } EndClipPathDisplayItem::~EndClipPathDisplayItem() { @@ -91,10 +97,6 @@ void EndClipPathDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_EndClipPath); } -void EndClipPathDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_EndClipPath, proto.type()); -} - void EndClipPathDisplayItem::Raster( SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, @@ -110,4 +112,8 @@ void EndClipPathDisplayItem::AsValueInto( visual_rect.ToString().c_str())); } +size_t EndClipPathDisplayItem::ExternalMemoryUsage() const { + return 0; +} + } // namespace cc diff --git a/cc/playback/clip_path_display_item.h b/cc/playback/clip_path_display_item.h index 6f37ebe..f3eaa0a 100644 --- a/cc/playback/clip_path_display_item.h +++ b/cc/playback/clip_path_display_item.h @@ -17,20 +17,24 @@ namespace cc { class CC_EXPORT ClipPathDisplayItem : public DisplayItem { public: - ClipPathDisplayItem(); + ClipPathDisplayItem(const SkPath& path, SkRegion::Op clip_op, bool antialias); + explicit ClipPathDisplayItem(const proto::DisplayItem& proto); ~ClipPathDisplayItem() override; - void SetNew(const SkPath& path, SkRegion::Op clip_op, bool antialias); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 1; } + bool IsSuitableForGpuRasterization() const { return true; } private: + void SetNew(const SkPath& path, SkRegion::Op clip_op, bool antialias); + SkPath clip_path_; SkRegion::Op clip_op_; bool antialias_; @@ -39,6 +43,7 @@ class CC_EXPORT ClipPathDisplayItem : public DisplayItem { class CC_EXPORT EndClipPathDisplayItem : public DisplayItem { public: EndClipPathDisplayItem(); + explicit EndClipPathDisplayItem(const proto::DisplayItem& proto); ~EndClipPathDisplayItem() override; static scoped_ptr<EndClipPathDisplayItem> Create() { @@ -46,12 +51,15 @@ class CC_EXPORT EndClipPathDisplayItem : public DisplayItem { } void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 0; } + bool IsSuitableForGpuRasterization() const { return true; } }; } // namespace cc diff --git a/cc/playback/compositing_display_item.cc b/cc/playback/compositing_display_item.cc index 667371b..b9cd395 100644 --- a/cc/playback/compositing_display_item.cc +++ b/cc/playback/compositing_display_item.cc @@ -19,7 +19,35 @@ namespace cc { -CompositingDisplayItem::CompositingDisplayItem() { +CompositingDisplayItem::CompositingDisplayItem(uint8_t alpha, + SkXfermode::Mode xfermode, + SkRect* bounds, + skia::RefPtr<SkColorFilter> cf) { + SetNew(alpha, xfermode, bounds, std::move(cf)); +} + +CompositingDisplayItem::CompositingDisplayItem( + const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_Compositing, proto.type()); + + const proto::CompositingDisplayItem& details = proto.compositing_item(); + uint8_t alpha = static_cast<uint8_t>(details.alpha()); + SkXfermode::Mode xfermode = SkXfermodeModeFromProto(details.mode()); + scoped_ptr<SkRect> bounds; + if (details.has_bounds()) { + bounds.reset( + new SkRect(gfx::RectFToSkRect(ProtoToRectF(details.bounds())))); + } + + skia::RefPtr<SkColorFilter> filter; + if (details.has_color_filter()) { + SkFlattenable* flattenable = SkValidatingDeserializeFlattenable( + details.color_filter().c_str(), details.color_filter().size(), + SkColorFilter::GetFlattenableType()); + filter = skia::AdoptRef(static_cast<SkColorFilter*>(flattenable)); + } + + SetNew(alpha, xfermode, bounds.get(), std::move(filter)); } CompositingDisplayItem::~CompositingDisplayItem() { @@ -34,12 +62,7 @@ void CompositingDisplayItem::SetNew(uint8_t alpha, has_bounds_ = !!bounds; if (bounds) bounds_ = SkRect(*bounds); - color_filter_ = cf; - - // TODO(pdr): Include color_filter's memory here. - size_t external_memory_usage = 0; - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 1 /* op_count */, - external_memory_usage); + color_filter_ = std::move(cf); } void CompositingDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { @@ -59,29 +82,6 @@ void CompositingDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { } } -void CompositingDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_Compositing, proto.type()); - - const proto::CompositingDisplayItem& details = proto.compositing_item(); - uint8_t alpha = static_cast<uint8_t>(details.alpha()); - SkXfermode::Mode xfermode = SkXfermodeModeFromProto(details.mode()); - scoped_ptr<SkRect> bounds; - if (details.has_bounds()) { - bounds.reset( - new SkRect(gfx::RectFToSkRect(ProtoToRectF(details.bounds())))); - } - - skia::RefPtr<SkColorFilter> filter; - if (details.has_color_filter()) { - SkFlattenable* flattenable = SkValidatingDeserializeFlattenable( - details.color_filter().c_str(), details.color_filter().size(), - SkColorFilter::GetFlattenableType()); - filter = skia::AdoptRef(static_cast<SkColorFilter*>(flattenable)); - } - - SetNew(alpha, xfermode, bounds.get(), std::move(filter)); -} - void CompositingDisplayItem::Raster( SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, @@ -106,9 +106,16 @@ void CompositingDisplayItem::AsValueInto( static_cast<float>(bounds_.height()))); } -EndCompositingDisplayItem::EndCompositingDisplayItem() { - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 0 /* op_count */, - 0 /* external_memory_usage */); +size_t CompositingDisplayItem::ExternalMemoryUsage() const { + // TODO(pdr): Include color_filter's memory here. + return 0; +} + +EndCompositingDisplayItem::EndCompositingDisplayItem() {} + +EndCompositingDisplayItem::EndCompositingDisplayItem( + const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_EndCompositing, proto.type()); } EndCompositingDisplayItem::~EndCompositingDisplayItem() { @@ -118,10 +125,6 @@ void EndCompositingDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_EndCompositing); } -void EndCompositingDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_EndCompositing, proto.type()); -} - void EndCompositingDisplayItem::Raster( SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, @@ -137,4 +140,8 @@ void EndCompositingDisplayItem::AsValueInto( visual_rect.ToString().c_str())); } +size_t EndCompositingDisplayItem::ExternalMemoryUsage() const { + return 0; +} + } // namespace cc diff --git a/cc/playback/compositing_display_item.h b/cc/playback/compositing_display_item.h index 071308e..9512189 100644 --- a/cc/playback/compositing_display_item.h +++ b/cc/playback/compositing_display_item.h @@ -20,23 +20,30 @@ namespace cc { class CC_EXPORT CompositingDisplayItem : public DisplayItem { public: - CompositingDisplayItem(); + CompositingDisplayItem(uint8_t alpha, + SkXfermode::Mode xfermode, + SkRect* bounds, + skia::RefPtr<SkColorFilter> color_filter); + explicit CompositingDisplayItem(const proto::DisplayItem& proto); ~CompositingDisplayItem() override; - void SetNew(uint8_t alpha, - SkXfermode::Mode xfermode, - SkRect* bounds, - skia::RefPtr<SkColorFilter> color_filter); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 1; } + bool IsSuitableForGpuRasterization() const { return true; } private: + void SetNew(uint8_t alpha, + SkXfermode::Mode xfermode, + SkRect* bounds, + skia::RefPtr<SkColorFilter> color_filter); + uint8_t alpha_; SkXfermode::Mode xfermode_; bool has_bounds_; @@ -47,6 +54,7 @@ class CC_EXPORT CompositingDisplayItem : public DisplayItem { class CC_EXPORT EndCompositingDisplayItem : public DisplayItem { public: EndCompositingDisplayItem(); + explicit EndCompositingDisplayItem(const proto::DisplayItem& proto); ~EndCompositingDisplayItem() override; static scoped_ptr<EndCompositingDisplayItem> Create() { @@ -54,12 +62,15 @@ class CC_EXPORT EndCompositingDisplayItem : public DisplayItem { } void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 0; } + bool IsSuitableForGpuRasterization() const { return true; } }; } // namespace cc diff --git a/cc/playback/display_item.h b/cc/playback/display_item.h index e48d794..aeea050 100644 --- a/cc/playback/display_item.h +++ b/cc/playback/display_item.h @@ -23,37 +23,17 @@ class CC_EXPORT DisplayItem { public: virtual ~DisplayItem() {} - void SetNew(bool is_suitable_for_gpu_rasterization, - int approximate_op_count, - size_t external_memory_usage) { - is_suitable_for_gpu_rasterization_ = is_suitable_for_gpu_rasterization; - approximate_op_count_ = approximate_op_count; - external_memory_usage_ = external_memory_usage; - } - virtual void ToProtobuf(proto::DisplayItem* proto) const = 0; - virtual void FromProtobuf(const proto::DisplayItem& proto) = 0; virtual void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const = 0; virtual void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const = 0; - - bool is_suitable_for_gpu_rasterization() const { - return is_suitable_for_gpu_rasterization_; - } - int approximate_op_count() const { return approximate_op_count_; } - size_t external_memory_usage() const { return external_memory_usage_; } + // For tracing. + virtual size_t ExternalMemoryUsage() const = 0; protected: DisplayItem(); - - bool is_suitable_for_gpu_rasterization_; - int approximate_op_count_; - - // The size, in bytes, of the memory owned by this display item but not - // allocated within it (e.g. held through scoped_ptr or vector). - size_t external_memory_usage_; }; } // namespace cc diff --git a/cc/playback/display_item_list.cc b/cc/playback/display_item_list.cc index a1a9cdb..821dfce 100644 --- a/cc/playback/display_item_list.cc +++ b/cc/playback/display_item_list.cc @@ -16,6 +16,7 @@ #include "cc/debug/traced_value.h" #include "cc/playback/display_item_list_settings.h" #include "cc/playback/display_item_proto_factory.h" +#include "cc/playback/drawing_display_item.h" #include "cc/playback/largest_display_item.h" #include "cc/proto/display_item.pb.h" #include "cc/proto/gfx_conversions.h" @@ -61,10 +62,8 @@ scoped_refptr<DisplayItemList> DisplayItemList::CreateFromProto( for (int i = 0; i < proto.items_size(); i++) { const proto::DisplayItem& item_proto = proto.items(i); - DisplayItem* item = DisplayItemProtoFactory::AllocateAndConstruct( - layer_rect, list.get(), item_proto); - if (item) - item->FromProtobuf(item_proto); + DisplayItemProtoFactory::AllocateAndConstruct(layer_rect, list.get(), + item_proto); } return list; @@ -80,11 +79,7 @@ DisplayItemList::DisplayItemList(gfx::Rect layer_rect, 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 + picture_memory_usage_(0) { if (settings_.use_cached_picture) { SkRTreeFactory factory; recorder_.reset(new SkPictureRecorder()); @@ -115,7 +110,6 @@ void DisplayItemList::Raster(SkCanvas* canvas, SkPicture::AbortCallback* callback, const gfx::Rect& canvas_target_playback_rect, float contents_scale) const { - DCHECK(ProcessAppendedItemsCalled()); if (!settings_.use_cached_picture) { canvas->save(); canvas->scale(contents_scale, contents_scale); @@ -142,53 +136,19 @@ void DisplayItemList::Raster(SkCanvas* canvas, } } -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_) { - if (settings_.use_cached_picture) { - // When using a cached picture we will calculate gpu suitability on the - // entire cached picture instead of the items. This is more permissive - // 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. See crbug.com/513016. - DCHECK(canvas_); - approximate_op_count_ += item.approximate_op_count(); - item.Raster(canvas_.get(), gfx::Rect(), nullptr); - } else { - is_suitable_for_gpu_rasterization_ &= - item.is_suitable_for_gpu_rasterization(); - approximate_op_count_ += item.approximate_op_count(); - } - - 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(); - } +void DisplayItemList::ProcessAppendedItem(const DisplayItem* item) { + if (settings_.use_cached_picture) { + DCHECK(canvas_); + item->Raster(canvas_.get(), gfx::Rect(), nullptr); } - - if (!retain_individual_display_items_) + if (!retain_individual_display_items_) { items_.Clear(); + } } void DisplayItemList::RasterIntoCanvas(const DisplayItem& item) { DCHECK(canvas_); DCHECK(!retain_individual_display_items_); - approximate_op_count_ += item.approximate_op_count(); item.Raster(canvas_.get(), gfx::Rect(), nullptr); } @@ -197,15 +157,6 @@ 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(!settings_.use_cached_picture); - items_.RemoveLast(); -} - void DisplayItemList::Finalize() { // TODO(wkorman): Uncomment the assert below once we've investigated // and resolved issues. http://crbug.com/557905 @@ -216,8 +167,6 @@ void DisplayItemList::Finalize() { // them to stick around post-Finalize. http://crbug.com/527245 visual_rects_.clear(); - ProcessAppendedItems(); - if (settings_.use_cached_picture) { // Convert to an SkPicture for faster rasterization. DCHECK(settings_.use_cached_picture); @@ -228,23 +177,18 @@ void DisplayItemList::Finalize() { SkPictureUtils::ApproximateBytesUsed(picture_.get()); recorder_.reset(); canvas_.clear(); - is_suitable_for_gpu_rasterization_ = - picture_->suitableForGpuRasterization(nullptr); } } bool DisplayItemList::IsSuitableForGpuRasterization() const { - DCHECK(ProcessAppendedItemsCalled()); 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 (settings_.use_cached_picture && retain_individual_display_items_) return 0; @@ -253,8 +197,17 @@ size_t DisplayItemList::ApproximateMemoryUsage() const { size_t memory_usage = sizeof(*this); + size_t external_memory_usage = 0; + if (retain_individual_display_items_) { + // Warning: this double-counts SkPicture data if use_cached_picture is + // also true. + for (const auto& item : items_) { + external_memory_usage += item.ExternalMemoryUsage(); + } + } + // Memory outside this class due to |items_|. - memory_usage += items_.GetCapacityInBytes() + external_memory_usage_; + memory_usage += items_.GetCapacityInBytes() + external_memory_usage; // Memory outside this class due to |picture|. memory_usage += picture_memory_usage_; @@ -271,7 +224,6 @@ bool DisplayItemList::ShouldBeAnalyzedForSolidColor() const { 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(); @@ -310,7 +262,6 @@ DisplayItemList::AsValue(bool include_items) const { } 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") "," @@ -321,7 +272,6 @@ void DisplayItemList::EmitTraceSnapshot() const { } void DisplayItemList::GenerateDiscardableImagesMetadata() { - DCHECK(ProcessAppendedItemsCalled()); // This should be only called once, and only after CreateAndCacheSkPicture. DCHECK(image_map_.empty()); DCHECK(!settings_.use_cached_picture || picture_); diff --git a/cc/playback/display_item_list.h b/cc/playback/display_item_list.h index 4d24538..3ce1662 100644 --- a/cc/playback/display_item_list.h +++ b/cc/playback/display_item_list.h @@ -22,6 +22,8 @@ class SkCanvas; class SkPictureRecorder; namespace cc { +class DisplayItem; +class DrawingDisplayItem; namespace proto { class DisplayItemList; @@ -60,21 +62,24 @@ class CC_EXPORT DisplayItemList // is_suitable_for_gpu_rasterization_ and approximate_op_count_. void RasterIntoCanvas(const DisplayItem& display_item); - template <typename DisplayItemType> - DisplayItemType* CreateAndAppendItem(const gfx::Rect& visual_rect) { -#if DCHECK_IS_ON() - needs_process_ = true; -#endif + // Because processing happens in this function, all the set up for + // this item should be done via the args, which is why the return + // type needs to be const, to prevent set-after-processing mistakes. + template <typename DisplayItemType, typename... Args> + const DisplayItemType& CreateAndAppendItem(const gfx::Rect& visual_rect, + const Args&... args) { visual_rects_.push_back(visual_rect); - ProcessAppendedItemsOnTheFly(); - return &items_.AllocateAndConstruct<DisplayItemType>(); + // TODO(enne): This should forward the args. + auto* item = &items_.AllocateAndConstruct<DisplayItemType>(args...); + approximate_op_count_ += item->ApproximateOpCount(); + // TODO(crbug.com/513016): None of the items might individually trigger a + // veto even though they collectively have enough "bad" operations that a + // corresponding flattened Picture would get vetoed. + is_suitable_for_gpu_rasterization_ &= item->IsSuitableForGpuRasterization(); + ProcessAppendedItem(item); + return *item; } - // Removes the last item. This cannot be called on lists with cached pictures - // (since the data may already have been incorporated into cached picture - // sizes, etc). - void RemoveLast(); - // Called after all items are appended, to process the items and, if // applicable, create an internally cached SkPicture. void Finalize(); @@ -104,16 +109,7 @@ class CC_EXPORT DisplayItemList bool retain_individual_display_items); ~DisplayItemList(); - // While appending new items, if they are not being retained, this can process - // periodically to avoid retaining all the items and processing at the end. - void ProcessAppendedItemsOnTheFly(); - void ProcessAppendedItems(); -#if DCHECK_IS_ON() - bool ProcessAppendedItemsCalled() const { return !needs_process_; } - bool needs_process_; -#else - bool ProcessAppendedItemsCalled() const { return true; } -#endif + void ProcessAppendedItem(const DisplayItem* item); ContiguousContainer<DisplayItem> items_; // The visual rects associated with each of the display items in the @@ -136,9 +132,6 @@ class CC_EXPORT DisplayItemList // Memory usage due to the cached SkPicture. size_t picture_memory_usage_; - // Memory usage due to external data held by display items. - size_t external_memory_usage_; - DiscardableImageMap image_map_; friend class base::RefCountedThreadSafe<DisplayItemList>; diff --git a/cc/playback/display_item_list_unittest.cc b/cc/playback/display_item_list_unittest.cc index b29baa3..d61a48dc 100644 --- a/cc/playback/display_item_list_unittest.cc +++ b/cc/playback/display_item_list_unittest.cc @@ -43,7 +43,6 @@ void AppendFirstSerializationTestPicture(scoped_refptr<DisplayItemList> list, gfx::PointF offset(2.f, 3.f); SkPictureRecorder recorder; skia::RefPtr<SkCanvas> canvas; - skia::RefPtr<SkPicture> picture; SkPaint red_paint; red_paint.setColor(SK_ColorRED); @@ -52,8 +51,8 @@ void AppendFirstSerializationTestPicture(scoped_refptr<DisplayItemList> list, offset.x(), offset.y(), layer_size.width(), layer_size.height()))); canvas->translate(offset.x(), offset.y()); canvas->drawRectCoords(0.f, 0.f, 4.f, 4.f, red_paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect)->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); } void AppendSecondSerializationTestPicture(scoped_refptr<DisplayItemList> list, @@ -61,7 +60,6 @@ void AppendSecondSerializationTestPicture(scoped_refptr<DisplayItemList> list, gfx::PointF offset(2.f, 2.f); SkPictureRecorder recorder; skia::RefPtr<SkCanvas> canvas; - skia::RefPtr<SkPicture> picture; SkPaint blue_paint; blue_paint.setColor(SK_ColorBLUE); @@ -70,8 +68,8 @@ void AppendSecondSerializationTestPicture(scoped_refptr<DisplayItemList> list, offset.x(), offset.y(), layer_size.width(), layer_size.height()))); canvas->translate(offset.x(), offset.y()); canvas->drawRectCoords(3.f, 3.f, 7.f, 7.f, blue_paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect)->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); } void ValidateDisplayItemListSerialization(const gfx::Size& layer_size, @@ -151,8 +149,7 @@ TEST(DisplayItemListTest, SerializeClipItem) { gfx::Rect clip_rect(6, 6, 1, 1); std::vector<SkRRect> rrects; rrects.push_back(SkRRect::MakeOval(SkRect::MakeXYWH(5.f, 5.f, 4.f, 4.f))); - auto* item = list->CreateAndAppendItem<ClipDisplayItem>(kVisualRect); - item->SetNew(clip_rect, rrects); + list->CreateAndAppendItem<ClipDisplayItem>(kVisualRect, clip_rect, rrects); // Build the second DrawingDisplayItem. AppendSecondSerializationTestPicture(list, layer_size); @@ -176,8 +173,8 @@ TEST(DisplayItemListTest, SerializeClipPathItem) { // Build the ClipPathDisplayItem. SkPath path; path.addCircle(5.f, 5.f, 2.f, SkPath::Direction::kCW_Direction); - auto* item = list->CreateAndAppendItem<ClipPathDisplayItem>(kVisualRect); - item->SetNew(path, SkRegion::Op::kReplace_Op, false); + list->CreateAndAppendItem<ClipPathDisplayItem>( + kVisualRect, path, SkRegion::Op::kReplace_Op, false); // Build the second DrawingDisplayItem. AppendSecondSerializationTestPicture(list, layer_size); @@ -201,8 +198,8 @@ TEST(DisplayItemListTest, SerializeCompositingItem) { // Build the CompositingDisplayItem. skia::RefPtr<SkColorFilter> filter = skia::AdoptRef( SkColorFilter::CreateLightingFilter(SK_ColorRED, SK_ColorGREEN)); - auto* item = list->CreateAndAppendItem<CompositingDisplayItem>(kVisualRect); - item->SetNew(150, SkXfermode::Mode::kDst_Mode, nullptr, filter); + list->CreateAndAppendItem<CompositingDisplayItem>( + kVisualRect, 150, SkXfermode::Mode::kDst_Mode, nullptr, filter); // Build the second DrawingDisplayItem. AppendSecondSerializationTestPicture(list, layer_size); @@ -225,8 +222,7 @@ TEST(DisplayItemListTest, SerializeFloatClipItem) { // Build the FloatClipDisplayItem. gfx::RectF clip_rect(6.f, 6.f, 1.f, 1.f); - auto* item2 = list->CreateAndAppendItem<FloatClipDisplayItem>(kVisualRect); - item2->SetNew(clip_rect); + list->CreateAndAppendItem<FloatClipDisplayItem>(kVisualRect, clip_rect); // Build the second DrawingDisplayItem. AppendSecondSerializationTestPicture(list, layer_size); @@ -251,8 +247,7 @@ TEST(DisplayItemListTest, SerializeTransformItem) { gfx::Transform transform; transform.Scale(1.25f, 1.25f); transform.Translate(-1.f, -1.f); - auto* item2 = list->CreateAndAppendItem<TransformDisplayItem>(kVisualRect); - item2->SetNew(transform); + list->CreateAndAppendItem<TransformDisplayItem>(kVisualRect, transform); // Build the second DrawingDisplayItem. AppendSecondSerializationTestPicture(list, layer_size); @@ -285,8 +280,8 @@ TEST(DisplayItemListTest, SingleDrawingItem) { canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect, + std::move(picture)); list->Finalize(); DrawDisplayList(pixels, layer_rect, list); @@ -311,7 +306,6 @@ TEST(DisplayItemListTest, ClipItem) { gfx::Rect layer_rect(100, 100); SkPictureRecorder recorder; skia::RefPtr<SkCanvas> canvas; - skia::RefPtr<SkPicture> picture; SkPaint blue_paint; blue_paint.setColor(SK_ColorBLUE); SkPaint red_paint; @@ -328,13 +322,12 @@ TEST(DisplayItemListTest, ClipItem) { recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect))); canvas->translate(first_offset.x(), first_offset.y()); canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item1 = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item1->SetNew(std::move(picture)); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); gfx::Rect clip_rect(60, 60, 10, 10); - auto* item2 = list->CreateAndAppendItem<ClipDisplayItem>(kVisualRect); - item2->SetNew(clip_rect, std::vector<SkRRect>()); + list->CreateAndAppendItem<ClipDisplayItem>(kVisualRect, clip_rect, + std::vector<SkRRect>()); gfx::PointF second_offset(2.f, 3.f); gfx::RectF second_recording_rect(second_offset, @@ -343,9 +336,8 @@ TEST(DisplayItemListTest, ClipItem) { recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect))); canvas->translate(second_offset.x(), second_offset.y()); canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item3 = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item3->SetNew(std::move(picture)); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); list->CreateAndAppendItem<EndClipDisplayItem>(kVisualRect); list->Finalize(); @@ -374,7 +366,6 @@ TEST(DisplayItemListTest, TransformItem) { gfx::Rect layer_rect(100, 100); SkPictureRecorder recorder; skia::RefPtr<SkCanvas> canvas; - skia::RefPtr<SkPicture> picture; SkPaint blue_paint; blue_paint.setColor(SK_ColorBLUE); SkPaint red_paint; @@ -391,14 +382,12 @@ TEST(DisplayItemListTest, TransformItem) { recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect))); canvas->translate(first_offset.x(), first_offset.y()); canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item1 = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item1->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); gfx::Transform transform; transform.Rotate(45.0); - auto* item2 = list->CreateAndAppendItem<TransformDisplayItem>(kVisualRect); - item2->SetNew(transform); + list->CreateAndAppendItem<TransformDisplayItem>(kVisualRect, transform); gfx::PointF second_offset(2.f, 3.f); gfx::RectF second_recording_rect(second_offset, @@ -407,9 +396,8 @@ TEST(DisplayItemListTest, TransformItem) { recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect))); canvas->translate(second_offset.x(), second_offset.y()); canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item3 = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item3->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); list->CreateAndAppendItem<EndTransformDisplayItem>(kVisualRect); list->Finalize(); @@ -466,8 +454,8 @@ TEST(DisplayItemListTest, FilterItem) { filters.Append(FilterOperation::CreateReferenceFilter(image_filter)); filters.Append(FilterOperation::CreateBrightnessFilter(0.5f)); gfx::RectF filter_bounds(10.f, 10.f, 50.f, 50.f); - auto* item = list->CreateAndAppendItem<FilterDisplayItem>(kVisualRect); - item->SetNew(filters, filter_bounds); + list->CreateAndAppendItem<FilterDisplayItem>(kVisualRect, filters, + filter_bounds); list->CreateAndAppendItem<EndFilterDisplayItem>(kVisualRect); list->Finalize(); @@ -511,9 +499,8 @@ TEST(DisplayItemListTest, CompactingItems) { canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item1 = list_without_caching->CreateAndAppendItem<DrawingDisplayItem>( - kVisualRect); - item1->SetNew(picture); + list_without_caching->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect, + picture); list_without_caching->Finalize(); DrawDisplayList(pixels, layer_rect, list_without_caching); @@ -522,9 +509,8 @@ TEST(DisplayItemListTest, CompactingItems) { caching_settings.use_cached_picture = true; scoped_refptr<DisplayItemList> list_with_caching = DisplayItemList::Create(layer_rect, caching_settings); - auto* item2 = - list_with_caching->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item2->SetNew(picture); + list_with_caching->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect, + picture); list_with_caching->Finalize(); DrawDisplayList(expected_pixels, layer_rect, list_with_caching); @@ -535,7 +521,6 @@ TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithCachedPicture) { gfx::Rect layer_rect(1000, 1000); SkPictureRecorder recorder; skia::RefPtr<SkCanvas> canvas; - skia::RefPtr<SkPicture> picture; DisplayItemListSettings settings; settings.use_cached_picture = true; @@ -556,10 +541,8 @@ TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithCachedPicture) { paint.setAntiAlias(true); canvas->drawPath(path, paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - DrawingDisplayItem* item = - list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); list->Finalize(); // A single DrawingDisplayItem with a large AA concave path shouldn't trigger @@ -571,29 +554,13 @@ TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithCachedPicture) { skia::SharePtr(recorder.beginRecording(gfx::RectToSkRect(layer_rect))); for (int i = 0; i < 10; ++i) canvas->drawPath(path, paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); list->Finalize(); // A single DrawingDisplayItem with several large AA concave paths should // trigger a veto. EXPECT_FALSE(list->IsSuitableForGpuRasterization()); - - list = DisplayItemList::Create(layer_rect, settings); - for (int i = 0; i < 10; ++i) { - canvas = - skia::SharePtr(recorder.beginRecording(gfx::RectToSkRect(layer_rect))); - canvas->drawPath(path, paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); - } - list->Finalize(); - - // Having several DrawingDisplayItems that each contain a large AA concave - // path should trigger a veto. - EXPECT_FALSE(list->IsSuitableForGpuRasterization()); } TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithoutCachedPicture) { @@ -621,10 +588,8 @@ TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithoutCachedPicture) { paint.setAntiAlias(true); canvas->drawPath(path, paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - DrawingDisplayItem* item = - list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); list->Finalize(); // A single DrawingDisplayItem with a large AA concave path shouldn't trigger @@ -636,9 +601,8 @@ TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithoutCachedPicture) { skia::SharePtr(recorder.beginRecording(gfx::RectToSkRect(layer_rect))); for (int i = 0; i < 10; ++i) canvas->drawPath(path, paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); list->Finalize(); // A single DrawingDisplayItem with several large AA concave paths should @@ -650,9 +614,8 @@ TEST(DisplayItemListTest, IsSuitableForGpuRasterizationWithoutCachedPicture) { canvas = skia::SharePtr(recorder.beginRecording(gfx::RectToSkRect(layer_rect))); canvas->drawPath(path, paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>( + kVisualRect, skia::AdoptRef(recorder.endRecordingAsPicture())); } list->Finalize(); @@ -684,8 +647,7 @@ TEST(DisplayItemListTest, ApproximateMemoryUsage) { DisplayItemListSettings caching_settings; caching_settings.use_cached_picture = true; list = DisplayItemList::Create(layer_rect, caching_settings); - auto* item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect, picture); list->Finalize(); memory_usage = list->ApproximateMemoryUsage(); EXPECT_GE(memory_usage, picture_size); @@ -695,8 +657,7 @@ TEST(DisplayItemListTest, ApproximateMemoryUsage) { DisplayItemListSettings no_caching_settings; no_caching_settings.use_cached_picture = false; list = DisplayItemList::Create(layer_rect, no_caching_settings); - item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect, picture); list->Finalize(); memory_usage = list->ApproximateMemoryUsage(); EXPECT_GE(memory_usage, picture_size); @@ -706,8 +667,7 @@ TEST(DisplayItemListTest, ApproximateMemoryUsage) { // picture and items are retained (currently this only happens due to certain // categories being traced). list = new DisplayItemList(layer_rect, caching_settings, true); - item = list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect); - item->SetNew(picture); + list->CreateAndAppendItem<DrawingDisplayItem>(kVisualRect, picture); list->Finalize(); memory_usage = list->ApproximateMemoryUsage(); EXPECT_EQ(static_cast<size_t>(0), memory_usage); diff --git a/cc/playback/display_item_proto_factory.cc b/cc/playback/display_item_proto_factory.cc index fa5c0d8..88d5066 100644 --- a/cc/playback/display_item_proto_factory.cc +++ b/cc/playback/display_item_proto_factory.cc @@ -17,41 +17,53 @@ namespace cc { // static -DisplayItem* DisplayItemProtoFactory::AllocateAndConstruct( +void DisplayItemProtoFactory::AllocateAndConstruct( const gfx::Rect& visual_rect, DisplayItemList* list, const proto::DisplayItem& proto) { switch (proto.type()) { case proto::DisplayItem::Type_Clip: - return list->CreateAndAppendItem<ClipDisplayItem>(visual_rect); + list->CreateAndAppendItem<ClipDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_EndClip: - return list->CreateAndAppendItem<EndClipDisplayItem>(visual_rect); + list->CreateAndAppendItem<EndClipDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_ClipPath: - return list->CreateAndAppendItem<ClipPathDisplayItem>(visual_rect); + list->CreateAndAppendItem<ClipPathDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_EndClipPath: - return list->CreateAndAppendItem<EndClipPathDisplayItem>(visual_rect); + list->CreateAndAppendItem<EndClipPathDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_Compositing: - return list->CreateAndAppendItem<CompositingDisplayItem>(visual_rect); + list->CreateAndAppendItem<CompositingDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_EndCompositing: - return list->CreateAndAppendItem<EndCompositingDisplayItem>(visual_rect); + list->CreateAndAppendItem<EndCompositingDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_Drawing: - return list->CreateAndAppendItem<DrawingDisplayItem>(visual_rect); + list->CreateAndAppendItem<DrawingDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_Filter: - return list->CreateAndAppendItem<FilterDisplayItem>(visual_rect); + list->CreateAndAppendItem<FilterDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_EndFilter: - return list->CreateAndAppendItem<EndFilterDisplayItem>(visual_rect); + list->CreateAndAppendItem<EndFilterDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_FloatClip: - return list->CreateAndAppendItem<FloatClipDisplayItem>(visual_rect); + list->CreateAndAppendItem<FloatClipDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_EndFloatClip: - return list->CreateAndAppendItem<EndFloatClipDisplayItem>(visual_rect); + list->CreateAndAppendItem<EndFloatClipDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_Transform: - return list->CreateAndAppendItem<TransformDisplayItem>(visual_rect); + list->CreateAndAppendItem<TransformDisplayItem>(visual_rect, proto); + return; case proto::DisplayItem::Type_EndTransform: - return list->CreateAndAppendItem<EndTransformDisplayItem>(visual_rect); + list->CreateAndAppendItem<EndTransformDisplayItem>(visual_rect, proto); + return; } NOTREACHED(); - return nullptr; } } // namespace cc diff --git a/cc/playback/display_item_proto_factory.h b/cc/playback/display_item_proto_factory.h index 327124a..edc6118 100644 --- a/cc/playback/display_item_proto_factory.h +++ b/cc/playback/display_item_proto_factory.h @@ -18,9 +18,9 @@ class DisplayItem; class DisplayItemProtoFactory { public: - static DisplayItem* AllocateAndConstruct(const gfx::Rect& visual_rect, - DisplayItemList* list, - const proto::DisplayItem& proto); + static void AllocateAndConstruct(const gfx::Rect& visual_rect, + DisplayItemList* list, + const proto::DisplayItem& proto); private: DisplayItemProtoFactory() {} diff --git a/cc/playback/drawing_display_item.cc b/cc/playback/drawing_display_item.cc index 0593577..f314608 100644 --- a/cc/playback/drawing_display_item.cc +++ b/cc/playback/drawing_display_item.cc @@ -21,7 +21,29 @@ namespace cc { -DrawingDisplayItem::DrawingDisplayItem() { +DrawingDisplayItem::DrawingDisplayItem() {} + +DrawingDisplayItem::DrawingDisplayItem(skia::RefPtr<SkPicture> picture) { + SetNew(std::move(picture)); +} + +DrawingDisplayItem::DrawingDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_Drawing, proto.type()); + + skia::RefPtr<SkPicture> picture; + const proto::DrawingDisplayItem& details = proto.drawing_item(); + if (details.has_picture()) { + SkMemoryStream stream(details.picture().data(), details.picture().size()); + + // TODO(dtrainor, nyquist): Add an image decoder. + picture = skia::AdoptRef(SkPicture::CreateFromStream(&stream, nullptr)); + } + + SetNew(std::move(picture)); +} + +DrawingDisplayItem::DrawingDisplayItem(const DrawingDisplayItem& item) { + item.CloneTo(this); } DrawingDisplayItem::~DrawingDisplayItem() { @@ -29,9 +51,6 @@ DrawingDisplayItem::~DrawingDisplayItem() { void DrawingDisplayItem::SetNew(skia::RefPtr<SkPicture> picture) { picture_ = std::move(picture); - DisplayItem::SetNew(picture_->suitableForGpuRasterization(NULL), - picture_->approximateOpCount(), - SkPictureUtils::ApproximateBytesUsed(picture_.get())); } void DrawingDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { @@ -53,21 +72,6 @@ void DrawingDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { } } -void DrawingDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_Drawing, proto.type()); - - skia::RefPtr<SkPicture> picture; - const proto::DrawingDisplayItem& details = proto.drawing_item(); - if (details.has_picture()) { - SkMemoryStream stream(details.picture().data(), details.picture().size()); - - // TODO(dtrainor, nyquist): Add an image decoder. - picture = skia::AdoptRef(SkPicture::CreateFromStream(&stream, nullptr)); - } - - SetNew(std::move(picture)); -} - void DrawingDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -119,4 +123,16 @@ void DrawingDisplayItem::CloneTo(DrawingDisplayItem* item) const { item->SetNew(picture_); } +size_t DrawingDisplayItem::ExternalMemoryUsage() const { + return SkPictureUtils::ApproximateBytesUsed(picture_.get()); +} + +int DrawingDisplayItem::ApproximateOpCount() const { + return picture_->approximateOpCount(); +} + +bool DrawingDisplayItem::IsSuitableForGpuRasterization() const { + return picture_->suitableForGpuRasterization(NULL); +} + } // namespace cc diff --git a/cc/playback/drawing_display_item.h b/cc/playback/drawing_display_item.h index c9083a3..261b3b3 100644 --- a/cc/playback/drawing_display_item.h +++ b/cc/playback/drawing_display_item.h @@ -19,21 +19,27 @@ namespace cc { class CC_EXPORT DrawingDisplayItem : public DisplayItem { public: DrawingDisplayItem(); + explicit DrawingDisplayItem(skia::RefPtr<SkPicture> picture); + explicit DrawingDisplayItem(const proto::DisplayItem& proto); + explicit DrawingDisplayItem(const DrawingDisplayItem& item); ~DrawingDisplayItem() override; - void SetNew(skia::RefPtr<SkPicture> picture); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const; + bool IsSuitableForGpuRasterization() const; void CloneTo(DrawingDisplayItem* item) const; private: + void SetNew(skia::RefPtr<SkPicture> picture); + skia::RefPtr<SkPicture> picture_; }; diff --git a/cc/playback/filter_display_item.cc b/cc/playback/filter_display_item.cc index ddf5957..d51da7c 100644 --- a/cc/playback/filter_display_item.cc +++ b/cc/playback/filter_display_item.cc @@ -18,22 +18,29 @@ namespace cc { -FilterDisplayItem::FilterDisplayItem() { +FilterDisplayItem::FilterDisplayItem(const FilterOperations& filters, + const gfx::RectF& bounds) { + SetNew(filters, bounds); } -FilterDisplayItem::~FilterDisplayItem() { +FilterDisplayItem::FilterDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_Filter, proto.type()); + + const proto::FilterDisplayItem& details = proto.filter_item(); + gfx::RectF bounds = ProtoToRectF(details.bounds()); + + // TODO(dtrainor): Support deserializing FilterOperations (crbug.com/541321). + FilterOperations filters; + + SetNew(filters, bounds); } +FilterDisplayItem::~FilterDisplayItem() {} + void FilterDisplayItem::SetNew(const FilterOperations& filters, const gfx::RectF& bounds) { filters_ = filters; bounds_ = bounds; - - // FilterOperations doesn't expose its capacity, but size is probably good - // enough. - size_t external_memory_usage = filters_.size() * sizeof(filters_.at(0)); - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 1 /* op_count */, - external_memory_usage); } void FilterDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { @@ -45,18 +52,6 @@ void FilterDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { // TODO(dtrainor): Support serializing FilterOperations (crbug.com/541321). } -void FilterDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_Filter, proto.type()); - - const proto::FilterDisplayItem& details = proto.filter_item(); - gfx::RectF bounds = ProtoToRectF(details.bounds()); - - // TODO(dtrainor): Support deserializing FilterOperations (crbug.com/541321). - FilterOperations filters; - - SetNew(filters, bounds); -} - void FilterDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -84,22 +79,24 @@ void FilterDisplayItem::AsValueInto( bounds_.ToString().c_str(), visual_rect.ToString().c_str())); } -EndFilterDisplayItem::EndFilterDisplayItem() { - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 0 /* op_count */, - 0 /* external_memory_usage */); +size_t FilterDisplayItem::ExternalMemoryUsage() const { + // FilterOperations doesn't expose its capacity, but size is probably good + // enough. + return filters_.size() * sizeof(filters_.at(0)); } -EndFilterDisplayItem::~EndFilterDisplayItem() { +EndFilterDisplayItem::EndFilterDisplayItem() {} + +EndFilterDisplayItem::EndFilterDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_EndFilter, proto.type()); } +EndFilterDisplayItem::~EndFilterDisplayItem() {} + void EndFilterDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_EndFilter); } -void EndFilterDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_EndFilter, proto.type()); -} - void EndFilterDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -115,4 +112,8 @@ void EndFilterDisplayItem::AsValueInto( visual_rect.ToString().c_str())); } +size_t EndFilterDisplayItem::ExternalMemoryUsage() const { + return 0; +} + } // namespace cc diff --git a/cc/playback/filter_display_item.h b/cc/playback/filter_display_item.h index 94bad21..c0a8df9 100644 --- a/cc/playback/filter_display_item.h +++ b/cc/playback/filter_display_item.h @@ -17,20 +17,24 @@ namespace cc { class CC_EXPORT FilterDisplayItem : public DisplayItem { public: - FilterDisplayItem(); + FilterDisplayItem(const FilterOperations& filters, const gfx::RectF& bounds); + explicit FilterDisplayItem(const proto::DisplayItem& proto); ~FilterDisplayItem() override; - void SetNew(const FilterOperations& filters, const gfx::RectF& bounds); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 1; } + bool IsSuitableForGpuRasterization() const { return true; } private: + void SetNew(const FilterOperations& filters, const gfx::RectF& bounds); + FilterOperations filters_; gfx::RectF bounds_; }; @@ -38,6 +42,7 @@ class CC_EXPORT FilterDisplayItem : public DisplayItem { class CC_EXPORT EndFilterDisplayItem : public DisplayItem { public: EndFilterDisplayItem(); + explicit EndFilterDisplayItem(const proto::DisplayItem& proto); ~EndFilterDisplayItem() override; static scoped_ptr<EndFilterDisplayItem> Create() { @@ -45,12 +50,15 @@ class CC_EXPORT EndFilterDisplayItem : public DisplayItem { } void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 0; } + bool IsSuitableForGpuRasterization() const { return true; } }; } // namespace cc diff --git a/cc/playback/float_clip_display_item.cc b/cc/playback/float_clip_display_item.cc index ae8e0b5..b57e640 100644 --- a/cc/playback/float_clip_display_item.cc +++ b/cc/playback/float_clip_display_item.cc @@ -13,7 +13,17 @@ namespace cc { -FloatClipDisplayItem::FloatClipDisplayItem() { +FloatClipDisplayItem::FloatClipDisplayItem(const gfx::RectF& clip_rect) { + SetNew(clip_rect); +} + +FloatClipDisplayItem::FloatClipDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_FloatClip, proto.type()); + + const proto::FloatClipDisplayItem& details = proto.float_clip_item(); + gfx::RectF clip_rect = ProtoToRectF(details.clip_rect()); + + SetNew(clip_rect); } FloatClipDisplayItem::~FloatClipDisplayItem() { @@ -21,9 +31,6 @@ FloatClipDisplayItem::~FloatClipDisplayItem() { void FloatClipDisplayItem::SetNew(const gfx::RectF& clip_rect) { clip_rect_ = clip_rect; - - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 1 /* op_count */, - 0 /* external_memory_usage */); } void FloatClipDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { @@ -33,15 +40,6 @@ void FloatClipDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { RectFToProto(clip_rect_, details->mutable_clip_rect()); } -void FloatClipDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_FloatClip, proto.type()); - - const proto::FloatClipDisplayItem& details = proto.float_clip_item(); - gfx::RectF clip_rect = ProtoToRectF(details.clip_rect()); - - SetNew(clip_rect); -} - void FloatClipDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -57,9 +55,15 @@ void FloatClipDisplayItem::AsValueInto( clip_rect_.ToString().c_str(), visual_rect.ToString().c_str())); } -EndFloatClipDisplayItem::EndFloatClipDisplayItem() { - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 0 /* op_count */, - 0 /* external_memory_usage */); +size_t FloatClipDisplayItem::ExternalMemoryUsage() const { + return 0; +} + +EndFloatClipDisplayItem::EndFloatClipDisplayItem() {} + +EndFloatClipDisplayItem::EndFloatClipDisplayItem( + const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_EndFloatClip, proto.type()); } EndFloatClipDisplayItem::~EndFloatClipDisplayItem() { @@ -69,10 +73,6 @@ void EndFloatClipDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_EndFloatClip); } -void EndFloatClipDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_EndFloatClip, proto.type()); -} - void EndFloatClipDisplayItem::Raster( SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, @@ -88,4 +88,8 @@ void EndFloatClipDisplayItem::AsValueInto( visual_rect.ToString().c_str())); } +size_t EndFloatClipDisplayItem::ExternalMemoryUsage() const { + return 0; +} + } // namespace cc diff --git a/cc/playback/float_clip_display_item.h b/cc/playback/float_clip_display_item.h index 3dd788b..6769c98 100644 --- a/cc/playback/float_clip_display_item.h +++ b/cc/playback/float_clip_display_item.h @@ -18,26 +18,31 @@ namespace cc { class CC_EXPORT FloatClipDisplayItem : public DisplayItem { public: - FloatClipDisplayItem(); + explicit FloatClipDisplayItem(const gfx::RectF& clip_rect); + explicit FloatClipDisplayItem(const proto::DisplayItem& proto); ~FloatClipDisplayItem() override; - void SetNew(const gfx::RectF& clip_rect); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 1; } + bool IsSuitableForGpuRasterization() const { return true; } private: + void SetNew(const gfx::RectF& clip_rect); + gfx::RectF clip_rect_; }; class CC_EXPORT EndFloatClipDisplayItem : public DisplayItem { public: EndFloatClipDisplayItem(); + explicit EndFloatClipDisplayItem(const proto::DisplayItem& proto); ~EndFloatClipDisplayItem() override; static scoped_ptr<EndFloatClipDisplayItem> Create() { @@ -45,12 +50,15 @@ class CC_EXPORT EndFloatClipDisplayItem : public DisplayItem { } void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 0; } + bool IsSuitableForGpuRasterization() const { return true; } }; } // namespace cc diff --git a/cc/playback/transform_display_item.cc b/cc/playback/transform_display_item.cc index f841854..8f7303c 100644 --- a/cc/playback/transform_display_item.cc +++ b/cc/playback/transform_display_item.cc @@ -12,8 +12,18 @@ namespace cc { -TransformDisplayItem::TransformDisplayItem() +TransformDisplayItem::TransformDisplayItem(const gfx::Transform& transform) : transform_(gfx::Transform::kSkipInitialization) { + SetNew(transform); +} + +TransformDisplayItem::TransformDisplayItem(const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_Transform, proto.type()); + + const proto::TransformDisplayItem& details = proto.transform_item(); + gfx::Transform transform = ProtoToTransform(details.transform()); + + SetNew(transform); } TransformDisplayItem::~TransformDisplayItem() { @@ -21,9 +31,6 @@ TransformDisplayItem::~TransformDisplayItem() { void TransformDisplayItem::SetNew(const gfx::Transform& transform) { transform_ = transform; - - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 1 /* op_count */, - 0 /* external_memory_usage */); } void TransformDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { @@ -33,15 +40,6 @@ void TransformDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { TransformToProto(transform_, details->mutable_transform()); } -void TransformDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_Transform, proto.type()); - - const proto::TransformDisplayItem& details = proto.transform_item(); - gfx::Transform transform = ProtoToTransform(details.transform()); - - SetNew(transform); -} - void TransformDisplayItem::Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const { @@ -58,9 +56,15 @@ void TransformDisplayItem::AsValueInto( transform_.ToString().c_str(), visual_rect.ToString().c_str())); } -EndTransformDisplayItem::EndTransformDisplayItem() { - DisplayItem::SetNew(true /* suitable_for_gpu_raster */, 0 /* op_count */, - 0 /* external_memory_usage */); +size_t TransformDisplayItem::ExternalMemoryUsage() const { + return 0; +} + +EndTransformDisplayItem::EndTransformDisplayItem() {} + +EndTransformDisplayItem::EndTransformDisplayItem( + const proto::DisplayItem& proto) { + DCHECK_EQ(proto::DisplayItem::Type_EndTransform, proto.type()); } EndTransformDisplayItem::~EndTransformDisplayItem() { @@ -70,10 +74,6 @@ void EndTransformDisplayItem::ToProtobuf(proto::DisplayItem* proto) const { proto->set_type(proto::DisplayItem::Type_EndTransform); } -void EndTransformDisplayItem::FromProtobuf(const proto::DisplayItem& proto) { - DCHECK_EQ(proto::DisplayItem::Type_EndTransform, proto.type()); -} - void EndTransformDisplayItem::Raster( SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, @@ -89,4 +89,8 @@ void EndTransformDisplayItem::AsValueInto( visual_rect.ToString().c_str())); } +size_t EndTransformDisplayItem::ExternalMemoryUsage() const { + return 0; +} + } // namespace cc diff --git a/cc/playback/transform_display_item.h b/cc/playback/transform_display_item.h index eb9d157..7e0a297 100644 --- a/cc/playback/transform_display_item.h +++ b/cc/playback/transform_display_item.h @@ -16,26 +16,31 @@ namespace cc { class CC_EXPORT TransformDisplayItem : public DisplayItem { public: - TransformDisplayItem(); + explicit TransformDisplayItem(const gfx::Transform& transform); + explicit TransformDisplayItem(const proto::DisplayItem& proto); ~TransformDisplayItem() override; - void SetNew(const gfx::Transform& transform); - void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 1; } + bool IsSuitableForGpuRasterization() const { return true; } private: + void SetNew(const gfx::Transform& transform); + gfx::Transform transform_; }; class CC_EXPORT EndTransformDisplayItem : public DisplayItem { public: EndTransformDisplayItem(); + explicit EndTransformDisplayItem(const proto::DisplayItem& proto); ~EndTransformDisplayItem() override; static scoped_ptr<EndTransformDisplayItem> Create() { @@ -43,12 +48,15 @@ class CC_EXPORT EndTransformDisplayItem : public DisplayItem { } void ToProtobuf(proto::DisplayItem* proto) const override; - void FromProtobuf(const proto::DisplayItem& proto) override; void Raster(SkCanvas* canvas, const gfx::Rect& canvas_target_playback_rect, SkPicture::AbortCallback* callback) const override; void AsValueInto(const gfx::Rect& visual_rect, base::trace_event::TracedValue* array) const override; + size_t ExternalMemoryUsage() const override; + + int ApproximateOpCount() const { return 0; } + bool IsSuitableForGpuRasterization() const { return true; } }; } // namespace cc diff --git a/cc/test/fake_content_layer_client.cc b/cc/test/fake_content_layer_client.cc index 6370a2e..ac8d282 100644 --- a/cc/test/fake_content_layer_client.cc +++ b/cc/test/fake_content_layer_client.cc @@ -52,7 +52,6 @@ FakeContentLayerClient::PaintContentsToDisplayList( DisplayItemList::Create(PaintableRegion(), settings); SkPictureRecorder recorder; skia::RefPtr<SkCanvas> canvas; - skia::RefPtr<SkPicture> picture; for (RectPaintVector::const_iterator it = draw_rects_.begin(); it != draw_rects_.end(); ++it) { @@ -61,27 +60,23 @@ FakeContentLayerClient::PaintContentsToDisplayList( canvas = skia::SharePtr(recorder.beginRecording(gfx::RectFToSkRect(draw_rect))); canvas->drawRect(gfx::RectFToSkRect(draw_rect), paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>( - ToEnclosingRect(draw_rect)); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + ToEnclosingRect(draw_rect), + skia::AdoptRef(recorder.endRecordingAsPicture())); } for (ImageVector::const_iterator it = draw_images_.begin(); it != draw_images_.end(); ++it) { if (!it->transform.IsIdentity()) { - auto* item = display_list->CreateAndAppendItem<TransformDisplayItem>( - PaintableRegion()); - item->SetNew(it->transform); + display_list->CreateAndAppendItem<TransformDisplayItem>(PaintableRegion(), + it->transform); } canvas = skia::SharePtr( recorder.beginRecording(it->image->width(), it->image->height())); canvas->drawImage(it->image.get(), it->point.x(), it->point.y(), &it->paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>( - PaintableRegion()); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + PaintableRegion(), skia::AdoptRef(recorder.endRecordingAsPicture())); if (!it->transform.IsIdentity()) { display_list->CreateAndAppendItem<EndTransformDisplayItem>( PaintableRegion()); @@ -97,10 +92,8 @@ FakeContentLayerClient::PaintContentsToDisplayList( canvas = skia::SharePtr(recorder.beginRecording(gfx::RectToSkRect(draw_rect))); canvas->drawIRect(gfx::RectToSkIRect(draw_rect), paint); - picture = skia::AdoptRef(recorder.endRecordingAsPicture()); - auto* item = - display_list->CreateAndAppendItem<DrawingDisplayItem>(draw_rect); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + draw_rect, skia::AdoptRef(recorder.endRecordingAsPicture())); draw_rect.Inset(1, 1); } } diff --git a/cc/test/solid_color_content_layer_client.cc b/cc/test/solid_color_content_layer_client.cc index c3518c3..a4f01ca 100644 --- a/cc/test/solid_color_content_layer_client.cc +++ b/cc/test/solid_color_content_layer_client.cc @@ -39,11 +39,9 @@ SolidColorContentLayerClient::PaintContentsToDisplayList( settings.use_cached_picture = false; scoped_refptr<DisplayItemList> display_list = DisplayItemList::Create(clip, settings); - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>(clip); - skia::RefPtr<SkPicture> picture = - skia::AdoptRef(recorder.endRecordingAsPicture()); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + clip, skia::AdoptRef(recorder.endRecordingAsPicture())); display_list->Finalize(); return display_list; diff --git a/cc/trees/layer_tree_host_pixeltest_masks.cc b/cc/trees/layer_tree_host_pixeltest_masks.cc index c8b5875..f913d51 100644 --- a/cc/trees/layer_tree_host_pixeltest_masks.cc +++ b/cc/trees/layer_tree_host_pixeltest_masks.cc @@ -58,12 +58,8 @@ class MaskContentLayerClient : public ContentLayerClient { scoped_refptr<DisplayItemList> display_list = DisplayItemList::Create(PaintableRegion(), DisplayItemListSettings()); - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>( - PaintableRegion()); - - skia::RefPtr<SkPicture> picture = - skia::AdoptRef(recorder.endRecordingAsPicture()); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + PaintableRegion(), skia::AdoptRef(recorder.endRecordingAsPicture())); display_list->Finalize(); return display_list; @@ -337,12 +333,8 @@ class CheckerContentLayerClient : public ContentLayerClient { scoped_refptr<DisplayItemList> display_list = DisplayItemList::Create(PaintableRegion(), DisplayItemListSettings()); - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>( - PaintableRegion()); - - skia::RefPtr<SkPicture> picture = - skia::AdoptRef(recorder.endRecordingAsPicture()); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + PaintableRegion(), skia::AdoptRef(recorder.endRecordingAsPicture())); display_list->Finalize(); return display_list; @@ -379,11 +371,8 @@ class CircleContentLayerClient : public ContentLayerClient { scoped_refptr<DisplayItemList> display_list = DisplayItemList::Create(PaintableRegion(), DisplayItemListSettings()); - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>( - PaintableRegion()); - skia::RefPtr<SkPicture> picture = - skia::AdoptRef(recorder.endRecordingAsPicture()); - item->SetNew(std::move(picture)); + display_list->CreateAndAppendItem<DrawingDisplayItem>( + PaintableRegion(), skia::AdoptRef(recorder.endRecordingAsPicture())); display_list->Finalize(); return display_list; diff --git a/cc/trees/layer_tree_host_pixeltest_tiles.cc b/cc/trees/layer_tree_host_pixeltest_tiles.cc index ec2303a..51457be 100644 --- a/cc/trees/layer_tree_host_pixeltest_tiles.cc +++ b/cc/trees/layer_tree_host_pixeltest_tiles.cc @@ -130,13 +130,8 @@ class BlueYellowClient : public ContentLayerClient { paint.setColor(SK_ColorYELLOW); canvas->drawRect(gfx::RectToSkRect(yellow_rect), paint); - skia::RefPtr<SkPicture> picture = - skia::AdoptRef(recorder.endRecordingAsPicture()); - - auto* item = display_list->CreateAndAppendItem<DrawingDisplayItem>( - PaintableRegion()); - item->SetNew(std::move(picture)); - + display_list->CreateAndAppendItem<DrawingDisplayItem>( + PaintableRegion(), skia::AdoptRef(recorder.endRecordingAsPicture())); display_list->Finalize(); return display_list; } diff --git a/ui/compositor/clip_recorder.cc b/ui/compositor/clip_recorder.cc index cec5c3d..164bd79 100644 --- a/ui/compositor/clip_recorder.cc +++ b/ui/compositor/clip_recorder.cc @@ -48,9 +48,8 @@ static gfx::Rect PathToEnclosingRect(const gfx::Path& path) { void ClipRecorder::ClipRect(const gfx::Rect& clip_rect) { gfx::Rect clip_in_layer_space = context_.ToLayerSpaceRect(clip_rect); - auto* item = context_.list_->CreateAndAppendItem<cc::ClipDisplayItem>( - clip_in_layer_space); - item->SetNew(clip_rect, std::vector<SkRRect>()); + context_.list_->CreateAndAppendItem<cc::ClipDisplayItem>( + clip_in_layer_space, clip_rect, std::vector<SkRRect>()); RecordCloser(clip_in_layer_space, CLIP_RECT); } @@ -58,9 +57,8 @@ void ClipRecorder::ClipPath(const gfx::Path& clip_path) { bool anti_alias = false; gfx::Rect clip_in_layer_space = context_.ToLayerSpaceRect(PathToEnclosingRect(clip_path)); - auto* item = context_.list_->CreateAndAppendItem<cc::ClipPathDisplayItem>( - clip_in_layer_space); - item->SetNew(clip_path, SkRegion::kIntersect_Op, anti_alias); + context_.list_->CreateAndAppendItem<cc::ClipPathDisplayItem>( + clip_in_layer_space, clip_path, SkRegion::kIntersect_Op, anti_alias); RecordCloser(clip_in_layer_space, CLIP_PATH); } @@ -68,9 +66,8 @@ void ClipRecorder::ClipPathWithAntiAliasing(const gfx::Path& clip_path) { bool anti_alias = true; gfx::Rect clip_in_layer_space = context_.ToLayerSpaceRect(PathToEnclosingRect(clip_path)); - auto* item = context_.list_->CreateAndAppendItem<cc::ClipPathDisplayItem>( - clip_in_layer_space); - item->SetNew(clip_path, SkRegion::kIntersect_Op, anti_alias); + context_.list_->CreateAndAppendItem<cc::ClipPathDisplayItem>( + clip_in_layer_space, clip_path, SkRegion::kIntersect_Op, anti_alias); RecordCloser(clip_in_layer_space, CLIP_PATH); } diff --git a/ui/compositor/compositing_recorder.cc b/ui/compositor/compositing_recorder.cc index f3d49cf..e103890 100644 --- a/ui/compositor/compositing_recorder.cc +++ b/ui/compositor/compositing_recorder.cc @@ -20,10 +20,9 @@ CompositingRecorder::CompositingRecorder(const PaintContext& context, if (!saved_) return; - auto* item = context_.list_->CreateAndAppendItem<cc::CompositingDisplayItem>( - bounds_in_layer_); - item->SetNew(alpha, SkXfermode::kSrcOver_Mode, nullptr /* no bounds */, - skia::RefPtr<SkColorFilter>()); + context_.list_->CreateAndAppendItem<cc::CompositingDisplayItem>( + bounds_in_layer_, alpha, SkXfermode::kSrcOver_Mode, + nullptr /* no bounds */, skia::RefPtr<SkColorFilter>()); } CompositingRecorder::~CompositingRecorder() { diff --git a/ui/compositor/paint_cache.cc b/ui/compositor/paint_cache.cc index e9de88d1..ba3855a 100644 --- a/ui/compositor/paint_cache.cc +++ b/ui/compositor/paint_cache.cc @@ -21,14 +21,13 @@ bool PaintCache::UseCache(const PaintContext& context, return false; DCHECK(context.list_); gfx::Rect bounds_in_layer = context.ToLayerSpaceBounds(size_in_context); - auto* item = context.list_->CreateAndAppendItem<cc::DrawingDisplayItem>( - bounds_in_layer); - display_item_.CloneTo(item); + context.list_->CreateAndAppendItem<cc::DrawingDisplayItem>(bounds_in_layer, + display_item_); return true; } -void PaintCache::SetCache(const cc::DrawingDisplayItem* item) { - item->CloneTo(&display_item_); +void PaintCache::SetCache(const cc::DrawingDisplayItem& item) { + item.CloneTo(&display_item_); has_cache_ = true; } diff --git a/ui/compositor/paint_cache.h b/ui/compositor/paint_cache.h index 5161127..516424f 100644 --- a/ui/compositor/paint_cache.h +++ b/ui/compositor/paint_cache.h @@ -30,7 +30,7 @@ class COMPOSITOR_EXPORT PaintCache { // Only PaintRecorder can modify these. friend PaintRecorder; - void SetCache(const cc::DrawingDisplayItem* item); + void SetCache(const cc::DrawingDisplayItem& item); bool has_cache_; cc::DrawingDisplayItem display_item_; diff --git a/ui/compositor/paint_recorder.cc b/ui/compositor/paint_recorder.cc index b3d497b..fef53c8 100644 --- a/ui/compositor/paint_recorder.cc +++ b/ui/compositor/paint_recorder.cc @@ -41,10 +41,10 @@ PaintRecorder::~PaintRecorder() { #if DCHECK_IS_ON() context_.inside_paint_recorder_ = false; #endif - - auto* item = context_.list_->CreateAndAppendItem<cc::DrawingDisplayItem>( - bounds_in_layer_); - item->SetNew(skia::AdoptRef(context_.recorder_->endRecordingAsPicture())); + const auto& item = + context_.list_->CreateAndAppendItem<cc::DrawingDisplayItem>( + bounds_in_layer_, + skia::AdoptRef(context_.recorder_->endRecordingAsPicture())); if (cache_) cache_->SetCache(item); } diff --git a/ui/compositor/transform_recorder.cc b/ui/compositor/transform_recorder.cc index 77448fd..5867a54 100644 --- a/ui/compositor/transform_recorder.cc +++ b/ui/compositor/transform_recorder.cc @@ -23,9 +23,8 @@ void TransformRecorder::Transform(const gfx::Transform& transform, const gfx::Size& size_in_context) { DCHECK(!transformed_); bounds_in_layer_ = context_.ToLayerSpaceBounds(size_in_context); - auto* item = context_.list_->CreateAndAppendItem<cc::TransformDisplayItem>( - bounds_in_layer_); - item->SetNew(transform); + context_.list_->CreateAndAppendItem<cc::TransformDisplayItem>( + bounds_in_layer_, transform); transformed_ = true; } |