FlutterBackBufferCache Class Reference

#import <FlutterSurfaceManager.h>

Inheritance diagram for FlutterBackBufferCache:

Instance Methods
(nullable FlutterSurface *)	- removeSurfaceForSize:
(void)	- returnSurfaces:
(NSUInteger)	- count

Detailed Description

Cache of back buffers to prevent unnecessary IOSurface allocations.

Definition at line 81 of file FlutterSurfaceManager.h.

Method Documentation

count

- (NSUInteger) count

Returns number of surfaces currently in cache. Used for tests.

Definition at line 352 of file FlutterSurfaceManager.mm.

                    {
  @synchronized(self) {
    return _surfaces.count;
  }
}

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

removeSurfaceForSize:

- (nullable FlutterSurface *) removeSurfaceForSize:

(CGSize)

size

Removes surface with given size from cache (if available) and returns it.

Definition at line 301 of file FlutterSurfaceManager.mm.

                                                :(CGSize)size {
  @synchronized(self) {
    // Purge all cached surfaces if the size has changed.
    if (_surfaces.firstObject != nil && !CGSizeEqualToSize(_surfaces.firstObject.size, size)) {
      [_surfaces removeAllObjects];
    }
 
    FlutterSurface* res;
 
    // Returns youngest surface that is not in use. Returning youngest surface ensures
    // that the cache doesn't keep more surfaces than it needs to, as the unused surfaces
    // kept in cache will have their age kept increasing until purged (inside [returnSurfaces:]).
    for (FlutterSurface* surface in _surfaces) {
      if (!surface.isInUse &&
          (res == nil || [self ageForSurface:res] > [self ageForSurface:surface])) {
        res = surface;
      }
    }
    if (res != nil) {
      [_surfaces removeObject:res];
    }
    return res;
  }
}

References FlutterSurface::isInUse.

returnSurfaces:

- (void) returnSurfaces:

(nonnull NSArray<FlutterSurface*>*)

surfaces

Removes all cached surfaces replacing them with new ones.

Definition at line 326 of file FlutterSurfaceManager.mm.

                      :(nonnull NSArray<FlutterSurface*>*)returnedSurfaces {
  @synchronized(self) {
    for (FlutterSurface* surface in returnedSurfaces) {
      [self setAge:0 forSurface:surface];
    }
    for (FlutterSurface* surface in _surfaces) {
      [self setAge:[self ageForSurface:surface] + 1 forSurface:surface];
    }
 
    [_surfaces addObjectsFromArray:returnedSurfaces];
 
    // Purge all surface with age = kSurfaceEvictionAge. Reaching this age can mean two things:
    // - Surface is still in use and we can't return it. This can happen in some edge
    //   cases where the compositor holds on to the surface for much longer than expected.
    // - Surface is not in use but it hasn't been requested from the cache for a while.
    //   This means there are too many surfaces in the cache.
    [_surfaces filterUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(FlutterSurface* surface,
                                                                          NSDictionary* bindings) {
                 return [self ageForSurface:surface] < kSurfaceEvictionAge;
               }]];
  }
 
  // performSelector:withObject:afterDelay needs to be performed on RunLoop thread
  [self performSelectorOnMainThread:@selector(reschedule) withObject:nil waitUntilDone:NO];
}

---

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

• shell/platform/darwin/macos/framework/Source/FlutterSurfaceManager.h
• shell/platform/darwin/macos/framework/Source/FlutterSurfaceManager.mm