flutter::OverlayLayerPool Class Reference

Storage for Overlay layers across frames. More...

#include <overlay_layer_pool.h>

Public Member Functions
	OverlayLayerPool ()=default
	~OverlayLayerPool ()=default
std::shared_ptr< OverlayLayer >	GetNextLayer ()
	Gets a layer from the pool if available. More...
void	CreateLayer (const std::shared_ptr< IOSContext > &ios_context, MTLPixelFormat pixel_format, CGFloat screenScale)
	Create a new overlay layer. More...
std::vector< std::shared_ptr< OverlayLayer > >	RemoveUnusedLayers ()
	Removes unused layers from the pool. Returns the unused layers. More...
void	RecycleLayers ()
	Marks the layers in the pool as available for reuse. More...
size_t	size () const
	The count of layers currently in the pool. More...

Detailed Description

Storage for Overlay layers across frames.

Note: this class does not synchronize access to its layers or any layer removal. As it is currently used, layers must be created on the platform thread but other methods of it are called on the raster thread. This is safe as overlay layers are only ever added while the raster thread is latched.

Definition at line 47 of file overlay_layer_pool.h.

Constructor & Destructor Documentation

OverlayLayerPool()

flutter::OverlayLayerPool::OverlayLayerPool ( )

default

~OverlayLayerPool()

flutter::OverlayLayerPool::~OverlayLayerPool ( )

default

Member Function Documentation

CreateLayer()

void flutter::OverlayLayerPool::CreateLayer	(	const std::shared_ptr< IOSContext > &	ios_context,
		MTLPixelFormat	pixel_format,
		CGFloat	screenScale
	)

Create a new overlay layer.

This method can only be called on the Platform thread.

Definition at line 56 of file overlay_layer_pool.mm.

                                                        {
  FML_DCHECK([[NSThread currentThread] isMainThread]);
  std::shared_ptr<OverlayLayer> layer;
  UIView* overlay_view;
  UIView* overlay_view_wrapper;
 
  overlay_view = [[FlutterOverlayView alloc] initWithContentsScale:screenScale
                                                       pixelFormat:pixel_format];
  overlay_view_wrapper = [[FlutterOverlayView alloc] initWithContentsScale:screenScale
                                                               pixelFormat:pixel_format];
 
  CALayer* ca_layer = overlay_view.layer;
  std::unique_ptr<IOSSurface> ios_surface = IOSSurface::Create(ios_context, ca_layer);
  std::unique_ptr<Surface> surface = ios_surface->CreateGPUSurface();
 
  layer = std::make_shared<OverlayLayer>(overlay_view, overlay_view_wrapper, std::move(ios_surface),
                                         std::move(surface));
  // The overlay view wrapper masks the overlay view.
  // This is required to keep the backing surface size unchanged between frames.
  //
  // Otherwise, changing the size of the overlay would require a new surface,
  // which can be very expensive.
  //
  // This is the case of an animation in which the overlay size is changing in every frame.
  //
  // +------------------------+
  // |   overlay_view         |
  // |    +--------------+    |              +--------------+
  // |    |    wrapper   |    |  == mask =>  | overlay_view |
  // |    +--------------+    |              +--------------+
  // +------------------------+
  layer->overlay_view_wrapper.clipsToBounds = YES;
  [layer->overlay_view_wrapper addSubview:layer->overlay_view];
 
  layers_.push_back(layer);
}

References flutter::IOSSurface::Create().

GetNextLayer()

std::shared_ptr< OverlayLayer > flutter::OverlayLayerPool::GetNextLayer

(

)

Gets a layer from the pool if available.

The layer is marked as used until [RecycleLayers] is called.

Definition at line 46 of file overlay_layer_pool.mm.

                                                           {
  std::shared_ptr<OverlayLayer> result;
  if (available_layer_index_ < layers_.size()) {
    result = layers_[available_layer_index_];
    available_layer_index_++;
  }
 
  return result;
}

RecycleLayers()

void flutter::OverlayLayerPool::RecycleLayers

(

)

Marks the layers in the pool as available for reuse.

Definition at line 95 of file overlay_layer_pool.mm.

                                     {
  available_layer_index_ = 0;
}

RemoveUnusedLayers()

std::vector< std::shared_ptr< OverlayLayer > > flutter::OverlayLayerPool::RemoveUnusedLayers

(

)

Removes unused layers from the pool. Returns the unused layers.

Definition at line 99 of file overlay_layer_pool.mm.

                                                                            {
  std::vector<std::shared_ptr<OverlayLayer>> results;
  for (size_t i = available_layer_index_; i < layers_.size(); i++) {
    results.push_back(layers_[i]);
  }
  // Leave at least one overlay layer, to work around cases where scrolling
  // platform views under an app bar continually adds and removes an
  // overlay layer. This logic could be removed if https://github.com/flutter/flutter/issues/150646
  // is fixed.
  static constexpr size_t kLeakLayerCount = 1;
  size_t erase_offset = std::max(available_layer_index_, kLeakLayerCount);
  if (erase_offset < layers_.size()) {
    layers_.erase(layers_.begin() + erase_offset, layers_.end());
  }
  return results;
}

size()

size_t flutter::OverlayLayerPool::size

(

)

const

The count of layers currently in the pool.

Definition at line 116 of file overlay_layer_pool.mm.

                                    {
  return layers_.size();
}

---

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

• shell/platform/darwin/ios/framework/Source/overlay_layer_pool.h
• shell/platform/darwin/ios/framework/Source/overlay_layer_pool.mm