#include <container_layer.h>

Inheritance diagram for flutter::ContainerLayer:

Public Member Functions
	ContainerLayer ()

void	Diff (DiffContext context, const Layer old_layer) override

void	PreservePaintRegion (DiffContext *context) override

virtual void	Add (std::shared_ptr< Layer > layer)

void	Preroll (PrerollContext *context, const SkMatrix &matrix) override

void	Paint (PaintContext &context) const override

const std::vector< std::shared_ptr< Layer > > &	layers () const

virtual void	DiffChildren (DiffContext context, const ContainerLayer old_layer)

void	PaintChildren (PaintContext &context) const

const ContainerLayer *	as_container_layer () const override

const SkRect &	child_paint_bounds () const

Public Member Functions inherited from flutter::Layer
	Layer ()

virtual	~Layer ()

void	AssignOldLayer (Layer *old_layer)

virtual bool	IsReplacing (DiffContext context, const Layer old_layer) const

bool	subtree_has_platform_view () const

void	set_subtree_has_platform_view (bool value)

const SkRect &	paint_bounds () const

void	set_paint_bounds (const SkRect &paint_bounds)

bool	is_empty () const

bool	needs_painting (PaintContext &context) const

uint64_t	original_layer_id () const

uint64_t	unique_id () const

virtual const DisplayListLayer *	as_display_list_layer () const

virtual const TextureLayer *	as_texture_layer () const

virtual const PerformanceOverlayLayer *	as_performance_overlay_layer () const

virtual const testing::MockLayer *	as_mock_layer () const

Protected Member Functions
void	PrerollChildren (PrerollContext context, const SkMatrix &child_matrix, SkRect child_paint_bounds)

Static Protected Member Functions
static void	TryToPrepareRasterCache (PrerollContext context, Layer layer, const SkMatrix &matrix, RasterCacheLayerStrategy strategy)

Detailed Description

Definition at line 14 of file container_layer.h.

Constructor & Destructor Documentation

◆ ContainerLayer()

flutter::ContainerLayer::ContainerLayer ( )

Definition at line 11 of file container_layer.cc.

11 : child_paint_bounds_(SkRect::MakeEmpty()) {}

Member Function Documentation

◆ Add()

void flutter::ContainerLayer::Add ( std::shared_ptr< Layer > layer )

virtual

Definition at line 106 of file container_layer.cc.

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

                                                    {
   layers_.emplace_back(std::move(layer));
 }

◆ as_container_layer()

const ContainerLayer* flutter::ContainerLayer::as_container_layer ( ) const

inlineoverridevirtual

Reimplemented from flutter::Layer.

Definition at line 31 of file container_layer.h.

31 { return this; }

◆ child_paint_bounds()

const SkRect& flutter::ContainerLayer::child_paint_bounds ( ) const

inline

Definition at line 33 of file container_layer.h.

References PrerollChildren(), and TryToPrepareRasterCache().

Referenced by flutter::ImageFilterLayer::Paint(), flutter::BackdropFilterLayer::Preroll(), flutter::TransformLayer::Preroll(), flutter::PhysicalShapeLayer::Preroll(), Preroll(), flutter::ClipShapeLayer< SkRRect >::Preroll(), PrerollChildren(), and flutter::RasterCache::RasterizeLayer().

33 { return child_paint_bounds_; }

◆ Diff()

void flutter::ContainerLayer::Diff	(	DiffContext *	context,
		const Layer *	old_layer
	)

overridevirtual

Reimplemented from flutter::Layer.

Reimplemented in flutter::OpacityLayer, flutter::ClipShapeLayer< SkRect >, flutter::ClipShapeLayer< SkPath >, flutter::ClipShapeLayer< SkRRect >, flutter::PhysicalShapeLayer, flutter::ShaderMaskLayer, flutter::TransformLayer, and flutter::ImageFilterLayer.

Definition at line 13 of file container_layer.cc.

References flutter::DiffContext::CurrentSubtreeRegion(), DiffChildren(), and flutter::DiffContext::SetLayerPaintRegion().

Referenced by flutter::testing::DiffContextTest::DiffLayerTree().

                                                                       {
   auto old_container = static_cast<const ContainerLayer*>(old_layer);
   DiffContext::AutoSubtreeRestore subtree(context);
   DiffChildren(context, old_container);
   context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
 }

◆ DiffChildren()

void flutter::ContainerLayer::DiffChildren	(	DiffContext *	context,
		const ContainerLayer *	old_layer
	)

virtual

Definition at line 27 of file container_layer.cc.

References flutter::DiffContext::AddDamage(), flutter::DiffContext::AddExistingPaintRegion(), FML_DCHECK, flutter::DiffContext::GetOldLayerPaintRegion(), flutter::Layer::IsReplacing(), flutter::DiffContext::IsSubtreeDirty(), and flutter::DiffContext::MarkSubtreeDirty().

Referenced by flutter::BackdropFilterLayer::Diff(), flutter::ColorFilterLayer::Diff(), flutter::ImageFilterLayer::Diff(), Diff(), flutter::TransformLayer::Diff(), flutter::ShaderMaskLayer::Diff(), flutter::PhysicalShapeLayer::Diff(), flutter::ClipShapeLayer< SkRRect >::Diff(), flutter::OpacityLayer::Diff(), and layers().

                                                                    {
   if (context->IsSubtreeDirty()) {
     for (auto& layer : layers_) {
       layer->Diff(context, nullptr);
     }
     return;
   }
   FML_DCHECK(old_layer);
 
   const auto& prev_layers = old_layer->layers_;
 
   // first mismatched element
   int new_children_top = 0;
   int old_children_top = 0;
 
   // last mismatched element
   int new_children_bottom = layers_.size() - 1;
   int old_children_bottom = prev_layers.size() - 1;
 
   while ((old_children_top <= old_children_bottom) &&
          (new_children_top <= new_children_bottom)) {
     if (!layers_[new_children_top]->IsReplacing(
             context, prev_layers[old_children_top].get())) {
       break;
     }
     ++new_children_top;
     ++old_children_top;
   }
 
   while ((old_children_top <= old_children_bottom) &&
          (new_children_top <= new_children_bottom)) {
     if (!layers_[new_children_bottom]->IsReplacing(
             context, prev_layers[old_children_bottom].get())) {
       break;
     }
     --new_children_bottom;
     --old_children_bottom;
   }
 
   // old layers that don't match
   for (int i = old_children_top; i <= old_children_bottom; ++i) {
     auto layer = prev_layers[i];
     context->AddDamage(context->GetOldLayerPaintRegion(layer.get()));
   }
 
   for (int i = 0; i < static_cast<int>(layers_.size()); ++i) {
     if (i < new_children_top || i > new_children_bottom) {
       int i_prev =
           i < new_children_top ? i : prev_layers.size() - (layers_.size() - i);
       auto layer = layers_[i];
       auto prev_layer = prev_layers[i_prev];
       auto paint_region = context->GetOldLayerPaintRegion(prev_layer.get());
       if (layer == prev_layer && !paint_region.has_readback() &&
           !paint_region.has_texture()) {
         // for retained layers, stop processing the subtree and add existing
         // region; We know current subtree is not dirty (every ancestor up to
         // here matches) so the retained subtree will render identically to
         // previous frame; We can only do this if there is no readback in the
         // subtree. Layers that do readback must be able to register readback
         // inside Diff
         context->AddExistingPaintRegion(paint_region);
 
         // While we don't need to diff retained layers, we still need to
         // associate their paint region with current layer tree so that we can
         // retrieve it in next frame diff
         layer->PreservePaintRegion(context);
       } else {
         layer->Diff(context, prev_layer.get());
       }
     } else {
       DiffContext::AutoSubtreeRestore subtree(context);
       context->MarkSubtreeDirty();
       auto layer = layers_[i];
       layer->Diff(context, nullptr);
     }
   }
 }

◆ layers()

const std::vector<std::shared_ptr<Layer> >& flutter::ContainerLayer::layers ( ) const

inline

Definition at line 26 of file container_layer.h.

References DiffChildren(), and PaintChildren().

Referenced by flutter::RasterCache::Prepare(), and flutter::OpacityLayer::Preroll().

26 { return layers_; }

◆ Paint()

void flutter::ContainerLayer::Paint ( PaintContext & context ) const

overridevirtual

Implements flutter::Layer.

Reimplemented in flutter::ClipShapeLayer< SkRect >, flutter::ClipShapeLayer< SkPath >, flutter::ClipShapeLayer< SkRRect >, flutter::OpacityLayer, flutter::PhysicalShapeLayer, flutter::ShaderMaskLayer, flutter::TransformLayer, and flutter::ImageFilterLayer.

Definition at line 118 of file container_layer.cc.

References FML_DCHECK, flutter::Layer::needs_painting(), and PaintChildren().

                                                       {
   FML_DCHECK(needs_painting(context));
 
   PaintChildren(context);
 }

◆ PaintChildren()

void flutter::ContainerLayer::PaintChildren ( PaintContext & context ) const

Definition at line 176 of file container_layer.cc.

Referenced by layers(), flutter::BackdropFilterLayer::Paint(), flutter::ColorFilterLayer::Paint(), flutter::ImageFilterLayer::Paint(), flutter::TransformLayer::Paint(), flutter::ShaderMaskLayer::Paint(), Paint(), flutter::PhysicalShapeLayer::Paint(), flutter::OpacityLayer::Paint(), flutter::ClipShapeLayer< SkRRect >::Paint(), and flutter::RasterCache::RasterizeLayer().

                                                               {
   // We can no longer call FML_DCHECK here on the needs_painting(context)
   // condition as that test is only valid for the PaintContext that
   // is initially handed to a layer's Paint() method. By the time the
   // layer calls PaintChildren(), though, it may have modified the
   // PaintContext so the test doesn't work in this "context".
 
   // Intentionally not tracing here as there should be no self-time
   // and the trace event on this common function has a small overhead.
   for (auto& layer : layers_) {
     if (layer->needs_painting(context)) {
       layer->Paint(context);
     }
   }
 }

◆ Preroll()

void flutter::ContainerLayer::Preroll	(	PrerollContext *	context,
		const SkMatrix &	matrix
	)

overridevirtual

Reimplemented from flutter::Layer.

Reimplemented in flutter::ClipShapeLayer< SkRect >, flutter::ClipShapeLayer< SkPath >, flutter::ClipShapeLayer< SkRRect >, flutter::OpacityLayer, flutter::PhysicalShapeLayer, flutter::ShaderMaskLayer, flutter::TransformLayer, and flutter::ImageFilterLayer.

Definition at line 110 of file container_layer.cc.

References child_paint_bounds(), PrerollChildren(), flutter::Layer::set_paint_bounds(), and TRACE_EVENT0.

Referenced by flutter::ColorFilterLayer::Preroll(), flutter::ShaderMaskLayer::Preroll(), and flutter::OpacityLayer::Preroll().

                                                                             {
   TRACE_EVENT0("flutter", "ContainerLayer::Preroll");
 
   SkRect child_paint_bounds = SkRect::MakeEmpty();
   PrerollChildren(context, matrix, &child_paint_bounds);
   set_paint_bounds(child_paint_bounds);
 }

◆ PrerollChildren()

void flutter::ContainerLayer::PrerollChildren	(	PrerollContext *	context,
		const SkMatrix &	child_matrix,
		SkRect *	child_paint_bounds
	)

protected

Definition at line 131 of file container_layer.cc.

References child_paint_bounds(), FML_DCHECK, flutter::PrerollContext::has_platform_view, flutter::PrerollContext::has_texture_layer, flutter::safe_intersection_test(), flutter::Layer::set_subtree_has_platform_view(), and flutter::PrerollContext::subtree_can_inherit_opacity.

Referenced by child_paint_bounds(), flutter::BackdropFilterLayer::Preroll(), flutter::ImageFilterLayer::Preroll(), flutter::TransformLayer::Preroll(), flutter::PhysicalShapeLayer::Preroll(), Preroll(), and flutter::ClipShapeLayer< SkRRect >::Preroll().

                                                                  {
   // Platform views have no children, so context->has_platform_view should
   // always be false.
   FML_DCHECK(!context->has_platform_view);
   bool child_has_platform_view = false;
   bool child_has_texture_layer = false;
   bool subtree_can_inherit_opacity = context->subtree_can_inherit_opacity;
 
   for (auto& layer : layers_) {
     // Reset context->has_platform_view to false so that layers aren't treated
     // as if they have a platform view based on one being previously found in a
     // sibling tree.
     context->has_platform_view = false;
     // Initialize the "inherit opacity" flag to false and allow the layer to
     // override the answer during its |Preroll|
     context->subtree_can_inherit_opacity = false;
 
     layer->Preroll(context, child_matrix);
 
     subtree_can_inherit_opacity =
         subtree_can_inherit_opacity && context->subtree_can_inherit_opacity;
     if (subtree_can_inherit_opacity &&
         safe_intersection_test(child_paint_bounds, layer->paint_bounds())) {
       // This will allow inheritance by a linear sequence of non-overlapping
       // children, but will fail with a grid or other arbitrary 2D layout.
       // See https://github.com/flutter/flutter/issues/93899
       subtree_can_inherit_opacity = false;
     }
     child_paint_bounds->join(layer->paint_bounds());
 
     child_has_platform_view =
         child_has_platform_view || context->has_platform_view;
     child_has_texture_layer =
         child_has_texture_layer || context->has_texture_layer;
   }
 
   context->has_platform_view = child_has_platform_view;
   context->has_texture_layer = child_has_texture_layer;
   context->subtree_can_inherit_opacity = subtree_can_inherit_opacity;
   set_subtree_has_platform_view(child_has_platform_view);
   child_paint_bounds_ = *child_paint_bounds;
 }

◆ PreservePaintRegion()

void flutter::ContainerLayer::PreservePaintRegion ( DiffContext * context )

overridevirtual

Reimplemented from flutter::Layer.

Definition at line 20 of file container_layer.cc.

References flutter::Layer::PreservePaintRegion().

                                                              {
   Layer::PreservePaintRegion(context);
   for (auto& layer : layers_) {
     layer->PreservePaintRegion(context);
   }
 }

◆ TryToPrepareRasterCache()

void flutter::ContainerLayer::TryToPrepareRasterCache	(	PrerollContext *	context,
		Layer *	layer,
		const SkMatrix &	matrix,
		RasterCacheLayerStrategy	strategy
	)

staticprotected

Definition at line 192 of file container_layer.cc.

References flutter::PrerollContext::cull_rect, flutter::PrerollContext::has_platform_view, flutter::PrerollContext::has_texture_layer, flutter::Layer::paint_bounds(), flutter::RasterCache::Prepare(), flutter::PrerollContext::raster_cache, and flutter::RasterCache::Touch().

Referenced by child_paint_bounds(), flutter::ImageFilterLayer::Preroll(), flutter::ColorFilterLayer::Preroll(), flutter::ShaderMaskLayer::Preroll(), flutter::OpacityLayer::Preroll(), and flutter::ClipShapeLayer< SkRRect >::Preroll().

                                        {
   if (!context->has_platform_view && !context->has_texture_layer &&
       context->raster_cache &&
       SkRect::Intersects(context->cull_rect, layer->paint_bounds())) {
     context->raster_cache->Prepare(context, layer, matrix, strategy);
   } else if (context->raster_cache) {
     // Don't evict raster cache entry during partial repaint
     context->raster_cache->Touch(layer, matrix, strategy);
   }
 }

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

flow/layers/container_layer.h
flow/layers/container_layer.cc

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ContainerLayer()

Member Function Documentation

◆ Add()

◆ as_container_layer()

◆ child_paint_bounds()

◆ Diff()

◆ DiffChildren()

◆ layers()

◆ Paint()

◆ PaintChildren()

◆ Preroll()

◆ PrerollChildren()

◆ PreservePaintRegion()

◆ TryToPrepareRasterCache()