flutter::DisplayListRasterCacheItem Class Reference

#include <display_list_raster_cache_item.h>

Inheritance diagram for flutter::DisplayListRasterCacheItem:

Public Member Functions
	DisplayListRasterCacheItem (const sk_sp< DisplayList > &display_list, const SkPoint &offset, bool is_complex=true, bool will_change=false)
void	PrerollSetup (PrerollContext *context, const SkMatrix &matrix) override
void	PrerollFinalize (PrerollContext *context, const SkMatrix &matrix) override
bool	Draw (const PaintContext &context, const DlPaint *paint) const override
bool	Draw (const PaintContext &context, DlCanvas *canvas, const DlPaint *paint) const override
bool	TryToPrepareRasterCache (const PaintContext &context, bool parent_cached=false) const override
void	ModifyMatrix (SkPoint offset) const
const DisplayList *	display_list () const
Public Member Functions inherited from flutter::RasterCacheItem
	RasterCacheItem (RasterCacheKeyID key_id, CacheState cache_state=CacheState::kNone, unsigned child_entries=0)
virtual void	PrerollSetup (PrerollContext *context, const SkMatrix &matrix)=0
virtual void	PrerollFinalize (PrerollContext *context, const SkMatrix &matrix)=0
virtual bool	Draw (const PaintContext &context, const DlPaint *paint) const =0
virtual bool	Draw (const PaintContext &context, DlCanvas *canvas, const DlPaint *paint) const =0
virtual std::optional< RasterCacheKeyID >	GetId () const
virtual bool	TryToPrepareRasterCache (const PaintContext &context, bool parent_cached=false) const =0
unsigned	child_items () const
void	set_matrix (const SkMatrix &matrix)
CacheState	cache_state () const
bool	need_caching () const
virtual	~RasterCacheItem ()=default

Static Public Member Functions
static std::unique_ptr< DisplayListRasterCacheItem >	Make (const sk_sp< DisplayList > &, const SkPoint &offset, bool is_complex, bool will_change)

Additional Inherited Members
Public Types inherited from flutter::RasterCacheItem
enum	CacheState { kNone = 0 , kCurrent , kChildren }
Protected Attributes inherited from flutter::RasterCacheItem
RasterCacheKeyID	key_id_
CacheState	cache_state_ = CacheState::kNone
SkMatrix	matrix_
unsigned	child_items_

Detailed Description

Definition at line 21 of file display_list_raster_cache_item.h.

Constructor & Destructor Documentation

DisplayListRasterCacheItem()

flutter::DisplayListRasterCacheItem::DisplayListRasterCacheItem	(	const sk_sp< DisplayList > &	display_list,
		const SkPoint &	offset,
		bool	is_complex = true,
		bool	will_change = false
	)

Definition at line 51 of file display_list_raster_cache_item.cc.

    : RasterCacheItem(RasterCacheKeyID(display_list->unique_id(),
                                       RasterCacheKeyType::kDisplayList),
                      CacheState::kCurrent),
      display_list_(display_list),
      offset_(offset),
      is_complex_(is_complex),
      will_change_(will_change) {}

Member Function Documentation

display_list()

const DisplayList * flutter::DisplayListRasterCacheItem::display_list ( ) const

inline

Definition at line 52 of file display_list_raster_cache_item.h.

{ return display_list_.get(); }

Draw() [1/2]

bool flutter::DisplayListRasterCacheItem::Draw ( const PaintContext &  context, const DlPaint *  paint  ) const

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 126 of file display_list_raster_cache_item.cc.

                                                                  {
  return Draw(context, context.canvas, paint);
}

Draw() [2/2]

bool flutter::DisplayListRasterCacheItem::Draw ( const PaintContext &  context, DlCanvas *  canvas, const DlPaint *  paint  ) const

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 131 of file display_list_raster_cache_item.cc.

                                                                  {
  if (!context.raster_cache || !canvas) {
    return false;
  }
  if (cache_state_ == CacheState::kCurrent) {
    return context.raster_cache->Draw(key_id_, *canvas, paint,
                                      context.rendering_above_platform_view);
  }
  return false;
}

Make()

std::unique_ptr< DisplayListRasterCacheItem > flutter::DisplayListRasterCacheItem::Make ( const sk_sp< DisplayList > &  display_list, const SkPoint &  offset, bool  is_complex, bool  will_change  )

static

Definition at line 64 of file display_list_raster_cache_item.cc.

                      {
  return std::make_unique<DisplayListRasterCacheItem>(display_list, offset,
                                                      is_complex, will_change);
}

ModifyMatrix()

void flutter::DisplayListRasterCacheItem::ModifyMatrix ( SkPoint  offset ) const

inline

Definition at line 48 of file display_list_raster_cache_item.h.

                                          {
    matrix_ = matrix_.preTranslate(offset.x(), offset.y());
  }

PrerollFinalize()

void flutter::DisplayListRasterCacheItem::PrerollFinalize ( PrerollContext *  context, const SkMatrix &  matrix  )

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 102 of file display_list_raster_cache_item.cc.

                                                                         {
  if (cache_state_ == CacheState::kNone || !context->raster_cache ||
      !context->raster_cached_entries) {
    return;
  }
  auto* raster_cache = context->raster_cache;
  SkRect bounds = display_list_->bounds().makeOffset(offset_.x(), offset_.y());
  bool visible = !context->state_stack.content_culled(bounds);
  RasterCache::CacheInfo cache_info =
      raster_cache->MarkSeen(key_id_, matrix, visible);
  if (!visible ||
      cache_info.accesses_since_visible <= raster_cache->access_threshold()) {
    cache_state_ = kNone;
  } else {
    if (cache_info.has_image) {
      context->renderable_state_flags |=
          LayerStateStack::kCallerCanApplyOpacity;
    }
    cache_state_ = kCurrent;
  }
  return;
}

PrerollSetup()

void flutter::DisplayListRasterCacheItem::PrerollSetup ( PrerollContext *  context, const SkMatrix &  matrix  )

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 73 of file display_list_raster_cache_item.cc.

                                                                      {
  cache_state_ = CacheState::kNone;
  DisplayListComplexityCalculator* complexity_calculator =
      context->gr_context ? DisplayListComplexityCalculator::GetForBackend(
                                context->gr_context->backend())
                          : DisplayListComplexityCalculator::GetForSoftware();
 
  if (!IsDisplayListWorthRasterizing(display_list(), will_change_, is_complex_,
                                     complexity_calculator)) {
    // We only deal with display lists that are worthy of rasterization.
    return;
  }
 
  transformation_matrix_ = matrix;
  transformation_matrix_.preTranslate(offset_.x(), offset_.y());
 
  if (!transformation_matrix_.invert(nullptr)) {
    // The matrix was singular. No point in going further.
    return;
  }
 
  if (context->raster_cached_entries && context->raster_cache) {
    context->raster_cached_entries->push_back(this);
    cache_state_ = CacheState::kCurrent;
  }
  return;
}

TryToPrepareRasterCache()

bool flutter::DisplayListRasterCacheItem::TryToPrepareRasterCache ( const PaintContext &  context, bool  parent_cached = false  ) const

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 146 of file display_list_raster_cache_item.cc.

                              {
  // If we don't have raster_cache we should not cache the current display_list.
  // If the current node's ancestor has been cached we also should not cache the
  // current node. In the current frame, the raster_cache will collect all
  // display_list or picture_list to calculate the memory they used, we
  // shouldn't cache the current node if the memory is more significant than the
  // limit.
  auto id = GetId();
  FML_DCHECK(id.has_value());
  if (cache_state_ == kNone || !context.raster_cache || parent_cached ||
      !context.raster_cache->GenerateNewCacheInThisFrame() || !id.has_value()) {
    return false;
  }
  SkRect bounds = display_list_->bounds().makeOffset(offset_.x(), offset_.y());
  RasterCache::Context r_context = {
      // clang-format off
      .gr_context         = context.gr_context,
      .dst_color_space    = context.dst_color_space,
      .matrix             = transformation_matrix_,
      .logical_rect       = bounds,
      .flow_type          = flow_type,
      // clang-format on
  };
  return context.raster_cache->UpdateCacheEntry(
      id.value(), r_context,
      [display_list = display_list_](DlCanvas* canvas) {
        canvas->DrawDisplayList(display_list);
      },
      display_list_->rtree());
}

---

The documentation for this class was generated from the following files:

• flow/layers/display_list_raster_cache_item.h
• flow/layers/display_list_raster_cache_item.cc