flutter::LayerRasterCacheItem Class Reference

#include <layer_raster_cache_item.h>

Inheritance diagram for flutter::LayerRasterCacheItem:

Public Member Functions
	LayerRasterCacheItem (Layer *layer, int layer_cached_threshold=1, bool can_cache_children=false)
std::optional< RasterCacheKeyID >	GetId () const override
void	PrerollSetup (PrerollContext *context, const DlMatrix &matrix) override
void	PrerollFinalize (PrerollContext *context, const DlMatrix &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	MarkCacheChildren ()
void	MarkNotCacheChildren ()
bool	IsCacheChildren () const
Public Member Functions inherited from flutter::RasterCacheItem
	RasterCacheItem (RasterCacheKeyID key_id, CacheState cache_state=CacheState::kNone, unsigned child_entries=0)
unsigned	child_items () const
void	set_matrix (const DlMatrix &matrix)
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< LayerRasterCacheItem >	Make (Layer *, int layer_cache_threshold, bool can_cache_children=false)
	Create a LayerRasterCacheItem, connect a layer and manage the Layer's raster cache.

Protected Member Functions
const SkRect *	GetPaintBoundsFromLayer () const

Protected Attributes
Layer *	layer_
std::optional< RasterCacheKeyID >	layer_children_id_
int	layer_cached_threshold_ = 1
bool	can_cache_children_ = false
int	num_cache_attempts_ = 1
Protected Attributes inherited from flutter::RasterCacheItem
RasterCacheKeyID	key_id_
CacheState	cache_state_ = CacheState::kNone
SkMatrix	matrix_
unsigned	child_items_

Additional Inherited Members
Public Types inherited from flutter::RasterCacheItem
enum	CacheState {   kNone = 0 ,   kCurrent ,   kChildren }

Detailed Description

Definition at line 17 of file layer_raster_cache_item.h.

Constructor & Destructor Documentation

LayerRasterCacheItem()

flutter::LayerRasterCacheItem::LayerRasterCacheItem ( Layer *  layer, int  layer_cached_threshold = 1, bool  can_cache_children = false  )

explicit

Definition at line 15 of file layer_raster_cache_item.cc.

    : RasterCacheItem(
          RasterCacheKeyID(layer->unique_id(), RasterCacheKeyType::kLayer),
          // The layer raster_cache_item's cache state default value is none.
          CacheState::kNone),
      layer_(layer),
      layer_cached_threshold_(layer_cached_threshold),
      can_cache_children_(can_cache_children) {}

Member Function Documentation

Draw() [1/2]

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

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 171 of file layer_raster_cache_item.cc.

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

References flutter::PaintContext::canvas.

Referenced by flutter::testing::TEST_F().

Draw() [2/2]

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

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 176 of file layer_raster_cache_item.cc.

                                                            {
  if (!context.raster_cache || !canvas) {
    return false;
  }
  switch (cache_state_) {
    case RasterCacheItem::kNone:
      return false;
    case RasterCacheItem::kCurrent: {
      return context.raster_cache->Draw(key_id_, *canvas, paint,
                                        context.rendering_above_platform_view);
    }
    case RasterCacheItem::kChildren: {
      if (!layer_children_id_.has_value()) {
        return false;
      }
      return context.raster_cache->Draw(layer_children_id_.value(), *canvas,
                                        paint,
                                        context.rendering_above_platform_view);
    }
  }
}

References flutter::RasterCacheItem::kChildren, flutter::RasterCacheItem::kCurrent, flutter::RasterCacheItem::kNone, and flutter::PaintContext::rendering_above_platform_view.

GetId()

std::optional< RasterCacheKeyID > flutter::LayerRasterCacheItem::GetId ( ) const

overridevirtual

Reimplemented from flutter::RasterCacheItem.

Definition at line 80 of file layer_raster_cache_item.cc.

                                                                {
  switch (cache_state_) {
    case kCurrent:
      return key_id_;
    case kChildren:
      return layer_children_id_;
    default:
      return {};
  }
}

GetPaintBoundsFromLayer()

const SkRect * flutter::LayerRasterCacheItem::GetPaintBoundsFromLayer ( ) const

protected

Definition at line 91 of file layer_raster_cache_item.cc.

                                                                  {
  switch (cache_state_) {
    case CacheState::kCurrent:
      return &ToSkRect(layer_->paint_bounds());
    case CacheState::kChildren:
      FML_DCHECK(layer_->as_container_layer());
      return &ToSkRect(layer_->as_container_layer()->child_paint_bounds());
    default:
      FML_DCHECK(cache_state_ != CacheState::kNone);
      return nullptr;
  }
}

References FML_DCHECK, and flutter::ToSkRect().

IsCacheChildren()

bool flutter::LayerRasterCacheItem::IsCacheChildren ( ) const

inline

Definition at line 54 of file layer_raster_cache_item.h.

{ return cache_state_ == CacheState::kChildren; }

References flutter::RasterCacheItem::cache_state_, and flutter::RasterCacheItem::kChildren.

Make()

std::unique_ptr< LayerRasterCacheItem > flutter::LayerRasterCacheItem::Make ( Layer *  layer, int  layer_cache_threshold, bool  can_cache_children = false  )

static

Create a LayerRasterCacheItem, connect a layer and manage the Layer's raster cache.

Parameters

layer_cache_threshold	after how many frames to start trying to cache the layer self
can_cache_children	the layer can do a cache for his children

Definition at line 36 of file layer_raster_cache_item.cc.

                             {
  return std::make_unique<LayerRasterCacheItem>(layer, layer_cache_threshold,
                                                can_cache_children);
}

Referenced by flutter::CacheableContainerLayer::CacheableContainerLayer().

MarkCacheChildren()

void flutter::LayerRasterCacheItem::MarkCacheChildren ( )

inline

Definition at line 50 of file layer_raster_cache_item.h.

{ can_cache_children_ = true; }

References can_cache_children_.

MarkNotCacheChildren()

void flutter::LayerRasterCacheItem::MarkNotCacheChildren ( )

inline

Definition at line 52 of file layer_raster_cache_item.h.

{ can_cache_children_ = false; }

References can_cache_children_.

PrerollFinalize()

void flutter::LayerRasterCacheItem::PrerollFinalize ( PrerollContext *  context, const DlMatrix &  matrix  )

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 44 of file layer_raster_cache_item.cc.

                                                                   {
  if (!context->raster_cache || !context->raster_cached_entries) {
    return;
  }
  // We've marked the cache entry that we would like to cache so it stays
  // alive, but if the following conditions apply then we need to set our
  // state back to kDoNotCache so that we don't populate the entry later.
  if (context->has_platform_view || context->has_texture_layer ||
      context->state_stack.content_culled(layer_->paint_bounds())) {
    return;
  }
  child_items_ = context->raster_cached_entries->size() - child_items_;
  if (num_cache_attempts_ >= layer_cached_threshold_) {
    // the layer can be cached
    cache_state_ = CacheState::kCurrent;
    context->raster_cache->MarkSeen(key_id_, matrix_, true);
  } else {
    num_cache_attempts_++;
    // access current layer
    if (can_cache_children_) {
      if (!layer_children_id_.has_value()) {
        auto ids = RasterCacheKeyID::LayerChildrenIds(layer_);
        if (!ids.has_value()) {
          return;
        }
        layer_children_id_.emplace(std::move(ids.value()),
                                   RasterCacheKeyType::kLayerChildren);
      }
      cache_state_ = CacheState::kChildren;
      context->raster_cache->MarkSeen(layer_children_id_.value(), matrix_,
                                      true);
    }
  }
}

References flutter::LayerStateStack::content_culled(), flutter::PrerollContext::has_platform_view, flutter::PrerollContext::has_texture_layer, flutter::kLayerChildren, flutter::RasterCacheKeyID::LayerChildrenIds(), flutter::PrerollContext::raster_cached_entries, and flutter::PrerollContext::state_stack.

Referenced by flutter::testing::TEST_F().

PrerollSetup()

void flutter::LayerRasterCacheItem::PrerollSetup ( PrerollContext *  context, const DlMatrix &  matrix  )

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 26 of file layer_raster_cache_item.cc.

                                                                {
  cache_state_ = CacheState::kNone;
  if (context->raster_cache && context->raster_cached_entries) {
    context->raster_cached_entries->push_back(this);
    child_items_ = context->raster_cached_entries->size();
    set_matrix(matrix);
  }
}

References flutter::PrerollContext::raster_cached_entries.

Referenced by flutter::testing::TEST_F().

TryToPrepareRasterCache()

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

overridevirtual

Implements flutter::RasterCacheItem.

Definition at line 142 of file layer_raster_cache_item.cc.

                                                                             {
  auto maybe_id = GetId();
  if (!maybe_id.has_value() || !context.raster_cache || parent_cached) {
    return false;
  }
  if (cache_state_ != kNone) {
    if (const SkRect* paint_bounds = GetPaintBoundsFromLayer()) {
      RasterCache::Context r_context = {
          // clang-format off
          .gr_context         = context.gr_context,
          .dst_color_space    = context.dst_color_space,
          .matrix             = matrix_,
          .logical_rect       = *paint_bounds,
          .flow_type          = flow_type,
          // clang-format on
      };
      const auto& id = maybe_id.value();
      return context.raster_cache->UpdateCacheEntry(
          id, r_context,
          [ctx = context, cache_state = cache_state_,
           layer = layer_](DlCanvas* canvas) {
            Rasterize(cache_state, layer, ctx, canvas);
          });
    }
  }
  return false;
}

References flutter::PaintContext::dst_color_space, flutter::flow_type, flutter::PaintContext::gr_context, flutter::RasterCache::Context::gr_context, flutter::kNone, and flutter::Rasterize().

Referenced by flutter::testing::MockRasterCache::AddMockLayer(), and flutter::testing::TEST_F().

Member Data Documentation

can_cache_children_

bool flutter::LayerRasterCacheItem::can_cache_children_ = false

protected

Definition at line 67 of file layer_raster_cache_item.h.

Referenced by MarkCacheChildren(), and MarkNotCacheChildren().

layer_

Layer* flutter::LayerRasterCacheItem::layer_

protected

Definition at line 59 of file layer_raster_cache_item.h.

layer_cached_threshold_

int flutter::LayerRasterCacheItem::layer_cached_threshold_ = 1

protected

Definition at line 64 of file layer_raster_cache_item.h.

layer_children_id_

std::optional<RasterCacheKeyID> flutter::LayerRasterCacheItem::layer_children_id_

protected

Definition at line 62 of file layer_raster_cache_item.h.

num_cache_attempts_

int flutter::LayerRasterCacheItem::num_cache_attempts_ = 1

mutableprotected

Definition at line 69 of file layer_raster_cache_item.h.

---

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

• flow/layers/layer_raster_cache_item.h
• flow/layers/layer_raster_cache_item.cc