Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
flutter Namespace Reference

Namespaces

namespace  egl
 
namespace  gpu
 
namespace  internal
 
namespace  math
 
namespace  runtime
 
namespace  testing
 

Classes

class  AccessibilityBridge
 
class  AccessibilityBridgeIos
 Interface that represents an accessibility bridge for iOS. More...
 
class  AccessibilityBridgeMac
 
class  AccessibilityBridgeWindows
 
class  AlertPlatformNodeDelegate
 
class  AndroidContext
 Holds state that is shared across Android surfaces. More...
 
class  AndroidContextGLImpeller
 
class  AndroidContextGLSkia
 
class  AndroidContextVulkanImpeller
 
class  AndroidDisplay
 A |Display| that listens to refresh rate changes. More...
 
class  AndroidEGLSurface
 
class  AndroidEGLSurfaceDamage
 
class  AndroidEnvironmentGL
 
class  AndroidExternalViewEmbedder
 
class  AndroidImageGenerator
 
class  AndroidNativeWindow
 
class  AndroidShellHolder
 This is the Android owner of the core engine Shell. More...
 
class  AndroidSnapshotSurfaceProducer
 
class  AndroidSurface
 
class  AndroidSurfaceFactory
 
class  AndroidSurfaceFactoryImpl
 
class  AndroidSurfaceGLImpeller
 
class  AndroidSurfaceGLSkia
 
class  AndroidSurfaceMock
 
class  AndroidSurfaceSoftware
 
class  AndroidSurfaceVulkanImpeller
 
class  Animator
 
class  APKAssetMapping
 
class  APKAssetProvider
 
class  APKAssetProviderImpl
 
class  APKAssetProviderInternal
 
class  APNGImageGenerator
 
class  AppSnapshotIsolateConfiguration
 
class  AssetManager
 
class  AssetManagerFontProvider
 
class  AssetManagerFontStyleSet
 
class  AssetResolver
 
class  AutoCache
 
class  BackdropFilterEntry
 
class  BackdropFilterLayer
 
struct  Base64
 
class  BasicMessageChannel
 
class  BinaryMessenger
 
class  BinaryMessengerImpl
 
class  BoundsAccumulator
 
class  BuiltinSkiaCodecImageGenerator
 
class  BuiltinSkiaImageGenerator
 
class  ByteBufferStreamReader
 
class  ByteBufferStreamWriter
 
class  ByteStreamReader
 
class  ByteStreamWriter
 
class  CacheableContainerLayer
 
class  Canvas
 
class  CanvasGradient
 
class  CanvasImage
 
class  CanvasPath
 
class  CanvasPathMeasure
 
class  CanvasSpy
 
class  ClipPathEntry
 
class  ClipPathLayer
 
class  ClipRectEntry
 
class  ClipRectLayer
 
class  ClipRRectEntry
 
class  ClipRRectLayer
 
class  ClipShapeLayer
 
class  Codec
 
class  ColorFilter
 
class  ColorFilterEntry
 
class  ColorFilterLayer
 
class  ComplexityCalculatorHelper
 
class  Compositor
 
class  CompositorContext
 
class  CompositorOpenGL
 
class  CompositorSoftware
 
class  ConnectionCollection
 Maintains a current integer assigned to a name (connections). More...
 
class  ContainerLayer
 
class  ContextListener
 
struct  CpuUsageInfo
 CPU usage stats. num_threads is the number of threads owned by the process. It is to be noted that this is not per shell, there can be multiple shells within the process. total_cpu_usage is the percentage (between [0, 100]) cpu usage of the application. This is across all the cores, for example an application using 100% of all the core will report total_cpu_usage as 100, if it has 100% across 2 cores and 0% across the other cores, embedder must report total_cpu_usage as 50. More...
 
class  Culler
 
class  CursorHandler
 
struct  CustomAccessibilityAction
 
class  CustomEncodableValue
 
struct  Damage
 
class  DartCallbackCache
 
struct  DartCallbackRepresentation
 
class  DartIO
 
class  DartIsolate
 Represents an instance of a live isolate. An isolate is a separate Dart execution context. Different Dart isolates don't share memory and can be scheduled concurrently by the Dart VM on one of the Dart VM managed worker pool threads. More...
 
class  DartIsolateGroupData
 
class  DartProject
 
class  DartProjectTest
 
class  DartRuntimeHooks
 
class  DartServiceIsolate
 Utility methods for interacting with the DartVM managed service isolate present in debug and profile runtime modes. More...
 
class  DartSnapshot
 A read-only Dart heap snapshot, or, read-executable mapping of AOT compiled Dart code. More...
 
class  DartTimestampProvider
 TimestampProvider implementation that is backed by Dart_TimelineGetTicks. More...
 
class  DartUI
 
class  DartVM
 Describes a running instance of the Dart VM. There may only be one running instance of the Dart VM in the process at any given time. The Dart VM may be created and destroyed on any thread. Typically, the first Flutter shell instance running in the process bootstraps the Dart VM in the process as it starts up. This cost is borne on the platform task runner of that first Flutter shell. When the last Flutter shell instance is destroyed, the VM is destroyed as well if all shell instances were launched with the Settings::leak_vm flag set to false. If there is any shell launch in the process with leak_vm set to true, the VM is never shut down in the process. When the VM is shutdown, the cost of the shutdown is borne on the platform task runner of the last shell instance to be shut down. More...
 
class  DartVMData
 Provides thread-safe access to data that is necessary to bootstrap a new Dart VM instance. All snapshots referenced by this object are read-only. More...
 
class  DartVMRef
 
class  Data3x3
 
class  Data4x4
 
struct  DecompressResult
 
class  DefaultPointerDataDispatcher
 
class  DidDrawCanvas
 
class  DiffContext
 
class  DirectManipulationEventHandler
 
class  DirectManipulationOwner
 
class  DirectoryAssetBundle
 
struct  DispatchContext
 
class  Display
 
struct  DisplayData
 
class  DisplayList
 
class  DisplayListAttributeFlags
 
class  DisplayListBuilder
 
class  DisplayListComplexityCalculator
 
class  DisplayListEmbedderViewSlice
 
class  DisplayListFlags
 
class  DisplayListFlagsBase
 
class  DisplayListGLComplexityCalculator
 
class  DisplayListLayer
 
class  DisplayListMatrixClipTracker
 
class  DisplayListMetalComplexityCalculator
 
class  DisplayListNaiveComplexityCalculator
 
class  DisplayListOpFlags
 
class  DisplayListRasterCacheItem
 
class  DisplayListSpecialGeometryFlags
 
class  DisplayListStorage
 
class  DisplayManager
 Manages lifecycle of the connected displays. This class is thread-safe. More...
 
class  DlAttribute
 
class  DlAutoCanvasRestore
 
class  DlBlendColorFilter
 
class  DlBlurImageFilter
 
class  DlBlurMaskFilter
 
class  DlCanvas
 Developer-facing API for rendering anything within the engine. More...
 
class  DlCanvasDelegate
 
struct  DlColor
 
class  DlColorColorSource
 
class  DlColorFilter
 
class  DlColorFilterImageFilter
 
class  DlColorSource
 
class  DlComposeImageFilter
 
class  DlConicalGradientColorSource
 
class  DlDashPathEffect
 
class  DlDeferredImageGPUImpeller
 
class  DlDeferredImageGPUSkia
 
class  DlDilateImageFilter
 
class  DlErodeImageFilter
 
class  DlGradientColorSourceBase
 
class  DlImage
 Represents an image whose allocation is (usually) resident on device memory. More...
 
class  DlImageColorSource
 
class  DlImageFilter
 
class  DlImageGPU
 
class  DlImageSkia
 
class  DlLinearGradientColorSource
 
class  DlLinearToSrgbGammaColorFilter
 
class  DlLocalMatrixImageFilter
 
class  DlMaskFilter
 
class  DlMatrixColorFilter
 
class  DlMatrixColorSourceBase
 
class  DlMatrixImageFilter
 
struct  DLOp
 
class  DlOpReceiver
 Internal API for rendering recorded display lists to backends. More...
 
class  DlOpSpy
 
class  DlPaint
 
class  DlPathEffect
 
class  DlRadialGradientColorSource
 
class  DlRegion
 
class  DlRTree
 
class  DlRuntimeEffect
 
class  DlRuntimeEffectColorSource
 
class  DlRuntimeEffectImpeller
 
class  DlRuntimeEffectSkia
 
class  DlSkCanvasAdapter
 Backend implementation of |DlCanvas| for |SkCanvas|. More...
 
class  DlSkCanvasDispatcher
 Backend implementation of |DlOpReceiver| for |SkCanvas|. More...
 
class  DlSkPaintDispatchHelper
 
class  DlSrgbToLinearGammaColorFilter
 
class  DlStopwatchVisualizer
 
class  DlSweepGradientColorSource
 
class  DlVertexPainter
 Provides canvas-like painting methods that actually build vertices. More...
 
class  DlVertices
 Holds all of the data (both required and optional) for a DisplayList drawVertices call. More...
 
struct  DrawArcOp
 
struct  DrawAtlasBaseOp
 
struct  DrawAtlasCulledOp
 
struct  DrawAtlasOp
 
struct  DrawColorOp
 
struct  DrawDisplayListOp
 
struct  DrawImageRectOp
 
struct  DrawOpBase
 
struct  DrawPaintOp
 
struct  DrawPathOp
 
struct  DrawTextBlobOp
 
struct  DrawTextFrameOp
 
struct  DrawVerticesOp
 
class  DummyDelegate
 
class  EmbeddedViewParams
 
class  EmbedderEngine
 
class  EmbedderExternalTextureGL
 
class  EmbedderExternalTextureMetal
 
class  EmbedderExternalTextureResolver
 
class  EmbedderExternalView
 
class  EmbedderExternalViewEmbedder
 The external view embedder used by the generic embedder API. This class acts a proxy between the rasterizer and the embedder when the rasterizer is rendering into multiple layers. It asks the embedder for the render targets for the various layers the rasterizer is rendering into, recycles the render targets as necessary and converts rasterizer specific metadata into an embedder friendly format so that it can present the layers on-screen. More...
 
class  EmbedderLayers
 
class  EmbedderPlatformMessageResponse
 The platform message response subclass for responses to messages from the embedder to the framework. Message responses are fulfilled by the framework. More...
 
class  EmbedderRenderTarget
 Describes a surface whose backing store is managed by the embedder. The type of surface depends on the client rendering API used. The embedder is notified of the collection of this render target via a callback. More...
 
class  EmbedderRenderTargetCache
 A cache used to reference render targets that are owned by the embedder but needed by th engine to render a frame. More...
 
class  EmbedderRenderTargetImpeller
 
class  EmbedderRenderTargetSkia
 
class  EmbedderResources
 
class  EmbedderSemanticsUpdate
 
class  EmbedderSemanticsUpdate2
 
class  EmbedderSurface
 
class  EmbedderSurfaceGL
 
class  EmbedderSurfaceGLImpeller
 
class  EmbedderSurfaceMetal
 
class  EmbedderSurfaceMetalImpeller
 
class  EmbedderSurfaceSoftware
 
class  EmbedderSurfaceVulkan
 
class  EmbedderTaskRunner
 
class  EmbedderThreadHost
 
class  EmbedderViewSlice
 
class  EncodableValue
 
class  Engine
 
class  EngineLayer
 
class  EngineMethodResult
 
class  EngineModifier
 
class  EventChannel
 
class  EventLoop
 
class  EventSink
 
class  EventWatcher
 
class  ExternalTexture
 
class  ExternalTextureD3d
 
class  ExternalTexturePixelBuffer
 
class  ExternalViewEmbedder
 
class  FixedRefreshRateStopwatch
 Used for fixed refresh rate cases. More...
 
class  FixedRefreshRateUpdater
 Used for fixed refresh rate query cases. More...
 
class  Fixture
 
class  FlutterCompositor
 
class  FlutterDesktopMessenger
 
class  FlutterEngine
 
class  FlutterEventTracer
 
class  FlutterGpuTestClass
 
class  FlutterMain
 
class  FlutterPlatformNodeDelegate
 
class  FlutterPlatformNodeDelegateMac
 
class  FlutterPlatformNodeDelegateWindows
 
struct  FlutterPlatformViewLayer
 
class  FlutterPlatformViewLayerPool
 
class  FlutterPlatformViewsController
 
class  FlutterProjectBundle
 
class  FlutterSkiaVulkanMemoryAllocator
 
class  FlutterTextPlatformNode
 The ax platform node for a text field. More...
 
class  FlutterView
 
class  FlutterViewController
 
class  FlutterWindow
 
class  FlutterWindowController
 
class  FlutterWindowsEngine
 
class  FlutterWindowsTextureRegistrar
 
class  FlutterWindowsView
 
class  FlutterWindowsViewController
 Controls a view that displays Flutter content. More...
 
class  FontCollection
 
class  FragmentProgram
 
class  FrameDamage
 
struct  FrameItem
 
class  FrameTiming
 
class  FrameTimingsRecorder
 
class  GLContextDefaultResult
 
class  GLContextResult
 
class  GLContextSwitch
 
struct  GLFBOInfo
 
struct  GLFrameInfo
 
class  GLFWEventLoop
 
struct  GLPresentInfo
 
struct  GPUMTLTextureInfo
 
class  GPUSurfaceGLDelegate
 
class  GPUSurfaceGLImpeller
 
class  GPUSurfaceGLSkia
 
class  GPUSurfaceMetalDelegate
 Interface implemented by all platform surfaces that can present a metal backing store to the "screen". The GPU surface abstraction (which abstracts the client rendering API) uses this delegation pattern to tell the platform surface (which abstracts how backing stores fulfilled by the selected client rendering API end up on the "screen" on a particular platform) when the rasterizer needs to allocate and present the software backing store. More...
 
class  GPUSurfaceMetalImpeller
 
class  GPUSurfaceMetalSkia
 
class  GPUSurfaceSoftware
 
class  GPUSurfaceSoftwareDelegate
 Interface implemented by all platform surfaces that can present a software backing store to the "screen". The GPU surface abstraction (which abstracts the client rendering API) uses this delegation pattern to tell the platform surface (which abstracts how backing stores fulfilled by the selected client rendering API end up on the "screen" on a particular platform) when the rasterizer needs to allocate and present the software backing store. More...
 
class  GpuSurfaceTexture
 
class  GPUSurfaceVulkan
 A GPU surface backed by VkImages provided by a GPUSurfaceVulkanDelegate. More...
 
class  GPUSurfaceVulkanDelegate
 Interface implemented by all platform surfaces that can present a Vulkan backing store to the "screen". The GPU surface abstraction (which abstracts the client rendering API) uses this delegation pattern to tell the platform surface (which abstracts how backing stores fulfilled by the selected client rendering API end up on the "screen" on a particular platform) when the rasterizer needs to allocate and present the Vulkan backing store. More...
 
class  GPUSurfaceVulkanImpeller
 
struct  GpuUsageInfo
 Polled information related to the usage of the GPU. More...
 
class  HeadlessEventLoop
 
class  IgnoreAttributeDispatchHelper
 
class  IgnoreClipDispatchHelper
 
class  IgnoreDrawDispatchHelper
 
class  IgnoreTransformDispatchHelper
 
class  ImageDecoder
 
class  ImageDecoderImpeller
 
class  ImageDecoderSkia
 
class  ImageDescriptor
 Creates an image descriptor for encoded or decoded image data, describing the width, height, and bytes per pixel for that image. This class will hold a reference on the underlying image data, and in the case of compressed data, an ImageGenerator for the data. The Codec initialization actually happens in initEncoded, making initstantiateCodec a lightweight operation. More...
 
class  ImageEncodingImpeller
 
class  ImageExternalTexture
 
class  ImageExternalTextureGL
 
class  ImageExternalTextureGLImpeller
 
class  ImageExternalTextureGLSkia
 
class  ImageExternalTextureVK
 
class  ImageFilter
 
class  ImageFilterEntry
 
class  ImageFilterLayer
 
class  ImageFilterMutation
 
class  ImageGenerator
 The minimal interface necessary for defining a decoder that can be used for both single and multi-frame image decoding. Image generators can also optionally support decoding into a subscaled buffer. Implementers of ImageGenerator regularly keep internal state which is not thread safe, and so aliasing and parallel access should never be done with ImageGenerators. More...
 
class  ImageGeneratorRegistry
 Keeps a priority-ordered registry of image generator builders to be used when decoding images. This object must be created, accessed, and collected on the UI thread (typically the engine or its runtime controller). More...
 
class  ImageLRU
 
struct  ImageMetaData
 
class  ImageShader
 
class  ImmContext
 
class  ImmutableBuffer
 
class  ImpellerAllocator
 
class  IncomingMessageDispatcher
 
class  IntegralTransformEntry
 
class  IOManager
 
class  IOSContext
 Manages the lifetime of the on-screen and off-screen rendering contexts on iOS. On-screen contexts are used by Flutter for rendering into the surface. The lifecycle of this context may be tied to the lifecycle of the surface. On the other hand, the lifecycle of the off-screen context it tied to that of the platform view. This one object used to manage both context because GPU handles may need to be shared between the two context. To achieve this, context may need references to one another at creation time. This one object manages the creation, use and collection of both contexts in a client rendering API agnostic manner. More...
 
class  IOSContextMetalImpeller
 
class  IOSContextMetalSkia
 
class  IOSContextSoftware
 
class  IOSExternalTextureMetal
 
class  IOSExternalViewEmbedder
 
class  IOSSurface
 
class  IOSSurfaceMetalImpeller
 
class  IOSSurfaceMetalSkia
 
class  IOSSurfaceSoftware
 
class  IsolateConfiguration
 An isolate configuration is a collection of snapshots and asset managers that the engine will use to configure the isolate before invoking its root entrypoint. The set of snapshots must be sufficient for the engine to move the isolate from the |DartIsolate::Phase::LibrariesSetup| phase to the |DartIsolate::Phase::Ready| phase. Note that the isolate configuration will not be collected till the isolate tied to the configuration as well as any and all child isolates of that isolate are collected. The engine may ask the configuration to prepare multiple isolates. All subclasses of this class must be thread safe as the configuration may be created, collected and used on multiple threads. Usually these threads are engine or VM managed so care must be taken to ensure that subclasses do not reference any thread local state. More...
 
class  IsolateNameServer
 
class  IsolateNameServerNatives
 
class  JNIMock
 
class  JsonMessageCodec
 
class  JsonMethodCodec
 
class  KernelIsolateConfiguration
 
class  KernelListIsolateConfiguration
 
class  KeyboardHandlerBase
 
class  KeyboardHookHandler
 
class  KeyboardKeyChannelHandler
 
class  KeyboardKeyEmbedderHandler
 
class  KeyboardKeyHandler
 
class  KeyboardManager
 
struct  KeyData
 
class  KeyDataPacket
 
class  KeyEventHandler
 
struct  LanguageInfo
 
class  Layer
 
class  LayerRasterCacheItem
 
class  LayerSnapshotData
 
class  LayerSnapshotStore
 Collects snapshots of layers during frame rasterization. More...
 
class  LayerStateStack
 
class  LayerTree
 
struct  LayerTreeTask
 
struct  LayoutClue
 
struct  LayoutGoal
 
struct  LineMetrics
 
struct  LocaleStringAttribute
 
class  MallocDeviceBuffer
 
struct  MemoryUsageInfo
 Memory usage stats. dirty_memory_usage is the memory usage (in MB) such that the app uses its physical memory for dirty memory. Dirty memory is the memory data that cannot be paged to disk. owned_shared_memory_usage is the memory usage (in MB) such that the app uses its physical memory for shared memory, including loaded frameworks and executables. On iOS, it's physical memory - dirty memory. More...
 
class  MessageCodec
 
class  MethodCall
 
class  MethodChannel
 
class  MethodCodec
 
class  MethodResult
 
class  MethodResultFunctions
 
class  MultiFrameCodec
 
class  Mutator
 
class  MutatorsStack
 
class  NativeStringAttribute
 The peer class for all of the StringAttribute subclasses in semantics.dart. More...
 
class  NDKHelpers
 
class  NopCuller
 
class  OffscreenSurface
 
class  OpacityEntry
 
class  OpacityLayer
 
struct  OverlayLayer
 
class  Paint
 
struct  PaintContext
 
class  PaintData
 
class  PaintRegion
 
class  Paragraph
 
class  ParagraphBuilder
 
struct  PathData
 
class  PerformanceOverlayLayer
 
class  PersistentCache
 
struct  PhysicalWindowBounds
 
class  Picture
 
class  PictureRecorder
 
class  Pipeline
 
struct  PipelineProduceResult
 
class  PixelBufferTexture
 
class  PlatformConfiguration
 A class for holding and distributing platform-level information to and from the Dart code in Flutter's framework. More...
 
class  PlatformConfigurationClient
 A client interface that the RuntimeController uses to define handlers for PlatformConfiguration requests. More...
 
class  PlatformConfigurationNativeApi
 
struct  PlatformData
 
class  PlatformHandler
 
class  PlatformMessage
 
class  PlatformMessageHandler
 
class  PlatformMessageHandlerAndroid
 
class  PlatformMessageHandlerIos
 
class  PlatformMessageHandlerStorage
 
class  PlatformMessageResponse
 
class  PlatformMessageResponseAndroid
 
class  PlatformMessageResponseDart
 
class  PlatformMessageResponseDartPort
 A PlatformMessageResponse that will respond over a Dart port. More...
 
class  PlatformMessageResponseDarwin
 
class  PlatformView
 Platform views are created by the shell on the platform task runner. Unless explicitly specified, all platform view methods are called on the platform task runner as well. Platform views are usually sub-classed on a per platform basis and the bulk of the window system integration happens using that subclass. Since most platform window toolkits are usually only safe to access on a single "main" thread, any interaction that requires access to the underlying platform's window toolkit is routed through the platform view associated with that shell. This involves operations like settings up and tearing down the render surface, platform messages, interacting with accessibility features on the platform, input events, etc. More...
 
class  PlatformViewAndroid
 
class  PlatformViewAndroidDelegate
 
class  PlatformViewAndroidJNI
 
class  PlatformViewAndroidJNIImpl
 Concrete implementation of PlatformViewAndroidJNI that is compiled with the Android toolchain. More...
 
class  PlatformViewEmbedder
 
class  PlatformViewIOS
 
class  PlatformViewLayer
 
class  Plugin
 
class  PluginRegistrar
 
class  PluginRegistrarGlfw
 
class  PluginRegistrarManager
 
class  PluginRegistrarWindows
 
class  PluginRegistry
 
class  Point
 
struct  PointerData
 
class  PointerDataDispatcher
 
class  PointerDataPacket
 
class  PointerDataPacketConverter
 
struct  PointerLocation
 
struct  PointerState
 
class  PointExtensionSerializer
 
struct  PrerollContext
 
class  PrerollDelegate
 
class  ProfilerMetricsIOS
 Utility class that gathers profiling metrics used by flutter::SamplingProfiler. More...
 
struct  ProfileSample
 Container for the metrics we collect during each run of Sampler. This currently holds CpuUsageInfo and MemoryUsageInfo but the intent is to expand it to other metrics. More...
 
class  RasterCache
 
class  RasterCacheItem
 
class  RasterCacheKey
 
class  RasterCacheKeyID
 
struct  RasterCacheMetrics
 
class  RasterCacheResult
 
struct  RasterCacheUtil
 
class  Rasterizer
 
class  ReactorWorker
 
class  Rect
 
class  RectBoundsAccumulator
 
class  RefCountedDartWrappable
 
class  ResourceCacheLimitCalculator
 
class  ResourceCacheLimitItem
 
struct  RestoreOp
 
class  ReusableFragmentShader
 
struct  RotateOp
 
class  RRect
 
class  RTree
 
class  RTreeBoundsAccumulator
 
class  RTreeFactory
 
class  RunConfiguration
 Specifies all the configuration required by the runtime library to launch the root isolate. This object may be created on any thread but must be given to the |Run| call of the |Engine| on the UI thread. The configuration object is used to specify how the root isolate finds its snapshots, assets, root library and the "main" entrypoint. More...
 
class  RuntimeController
 
class  RuntimeDelegate
 
class  SamplingProfiler
 a Sampling Profiler that runs peridically and calls the Sampler which servers as a value function to gather various profiling metrics as represented by ProfileSample. These profiling metrics are then posted to the Dart VM Service timeline. More...
 
class  SaveEntry
 
struct  SaveLayerBackdropBoundsOp
 
struct  SaveLayerBackdropOp
 
struct  SaveLayerBoundsOp
 
class  SaveLayerEntry
 
struct  SaveLayerOp
 
class  SaveLayerOptions
 
struct  SaveOp
 
struct  SaveOpBase
 
struct  ScaleOp
 
class  Scene
 
class  SceneBuilder
 
class  SceneNode
 A scene node, which may be a deserialized ipscene asset. This node can be safely added as a child to multiple scene nodes, whether they're in the same scene or a different scene. The deserialized node itself is treated as immutable on the IO thread. More...
 
class  SceneShader
 
class  ScopedClipboardInterface
 
class  ScriptCompletionTaskObserver
 
struct  SemanticsNode
 
class  SemanticsUpdate
 
class  SemanticsUpdateBuilder
 
class  SequentialIdGenerator
 
class  ServiceProtocol
 
struct  SetBlendModeOp
 
struct  SetColorOp
 
struct  SetImageColorSourceOp
 
struct  SetRuntimeEffectColorSourceOp
 
struct  SetSharedImageFilterOp
 
struct  SetStrokeMiterOp
 
struct  SetStrokeWidthOp
 
struct  SetStyleOp
 
struct  Settings
 
class  SettingsPlugin
 
class  Shader
 
class  ShaderMaskLayer
 
class  Shell
 
struct  ShellArgs
 
class  ShellIOManager
 
class  ShellTestExternalViewEmbedder
 The external view embedder used by |ShellTestPlatformViewGL|. More...
 
class  SingleFrameCodec
 
class  Size
 
struct  SkewOp
 
class  SkiaConcurrentExecutor
 An interface used by Skia to schedule work on engine managed threads (usually workers in a concurrent message loop). More...
 
class  SkiaGPUObject
 
class  SkOptionalPaint
 
class  SkStopwatchVisualizer
 
class  SmoothPointerDataDispatcher
 
class  SnapshotController
 
class  SnapshotControllerImpeller
 
class  SnapshotControllerSkia
 
class  SnapshotDelegate
 
class  SnapshotSurfaceProducer
 
class  SomeData
 
class  SomeDataExtensionSerializer
 
struct  SpellOutStringAttribute
 
class  StandardCodecSerializer
 
class  StandardMessageCodec
 
class  StandardMethodCodec
 
class  Stopwatch
 
class  StopwatchVisualizer
 Abstract class for visualizing (i.e. drawing) a stopwatch. More...
 
class  StreamHandler
 
struct  StreamHandlerError
 
class  StreamHandlerFunctions
 
struct  StringAttribute
 
class  Surface
 Abstract Base Class that represents where we will be rendering content. More...
 
class  SurfaceFrame
 
class  SurfacePool
 
class  SurfaceTextureExternalTexture
 
class  SurfaceTextureExternalTextureGL
 
class  SurfaceTextureExternalTextureImpellerGL
 
class  SwitchableGLContext
 
class  TaskRunner
 
class  TaskRunners
 
class  TaskRunnerWindow
 
class  TestAccessibilityBridge
 
class  TestBinaryMessenger
 
class  TestCustomValue
 
class  TesterExternalViewEmbedder
 
class  TesterGPUSurfaceSoftware
 
class  TesterPlatformView
 
class  TestMetalContext
 
class  TestMetalSurface
 Creates a MTLTexture backed SkSurface and context that can be used to render to in unit-tests. More...
 
class  TestMetalSurfaceImpl
 
struct  TextEditingDelta
 A change in the state of an input field. More...
 
class  TextInputManager
 
class  TextInputModel
 
class  TextInputPlugin
 
class  TextRange
 
class  Texture
 
class  TextureLayer
 
class  TextureRegistrar
 
class  TextureRegistrarImpl
 
class  TextureRegistry
 
struct  ThreadHost
 The collection of all the threads used by the engine. More...
 
class  ThreadSnapshot
 
struct  Transform2DAffineOp
 
struct  TransformClipOpBase
 
struct  TransformFullPerspectiveOp
 
class  TransformLayer
 
class  TransformM44Entry
 
class  TransformMatrixEntry
 
struct  TransformResetOp
 
class  TranslateEntry
 
struct  TranslateOp
 
class  UIDartState
 
class  UnrefQueue
 
class  VariableRefreshRateDisplay
 A Display where the refresh rate can change over time. More...
 
class  VariableRefreshRateReporter
 
class  VectorCuller
 
class  Vertices
 
class  ViewModifier
 
struct  ViewportMetrics
 
class  VolatilePathTracker
 
class  VsyncWaiter
 
class  VsyncWaiterAndroid
 
class  VsyncWaiterEmbedder
 
class  VsyncWaiterFallback
 A |VsyncWaiter| that will fire at 60 fps irrespective of the vsync. More...
 
class  VsyncWaiterIOS
 
class  WindowBindingHandler
 
class  WindowBindingHandlerDelegate
 
struct  WindowFrame
 
class  WindowProcDelegateManager
 
struct  WindowProperties
 
class  WindowsLifecycleManager
 
class  WindowsProcTable
 

Typedefs

using TaskObserverAdd = std::function< void(intptr_t, fml::closure)>
 
using TaskObserverRemove = std::function< void(intptr_t)>
 
using UnhandledExceptionCallback = std::function< bool(const std::string &, const std::string &)>
 
using LogMessageCallback = std::function< void(const std::string &, const std::string &)>
 
using MappingCallback = std::function< std::unique_ptr< fml::Mapping >(void)>
 
using Mappings = std::vector< std::unique_ptr< const fml::Mapping > >
 
using MappingsCallback = std::function< Mappings(void)>
 
using FrameRasterizedCallback = std::function< void(const FrameTiming &)>
 
using Flags = DlVertices::Builder::Flags
 
using PaintRegionMap = std::map< uint64_t, PaintRegion >
 
using MutatorContext = LayerStateStack::MutatorContext
 
typedef void(* CheckerboardFunc) (DlCanvas *, const SkRect &)
 
using SkiaUnrefQueue = UnrefQueue< GrDirectContext >
 
using HardwareBufferKey = uint64_t
 
typedef CanvasImage Image
 
typedef CanvasPathMeasure PathMeasure
 
typedef CanvasGradient Gradient
 
typedef CanvasPath Path
 
using ImageGeneratorFactory = std::function< std::shared_ptr< ImageGenerator >(sk_sp< SkData > buffer)>
 ImageGeneratorFactory is the top level primitive for specifying an image decoder in Flutter. When called, it should return an ImageGenerator that typically compatible with the given input data.
 
using CustomAccessibilityActionUpdates = std::unordered_map< int32_t, CustomAccessibilityAction >
 
using SemanticsNodeUpdates = std::unordered_map< int32_t, SemanticsNode >
 
using StringAttributePtr = std::shared_ptr< flutter::StringAttribute >
 
using StringAttributes = std::vector< StringAttributePtr >
 
using ChildIsolatePreparer = std::function< bool(DartIsolate *)>
 
typedef size_t DisplayId
 
using PointerDataDispatcherMaker = std::function< std::unique_ptr< PointerDataDispatcher >(PointerDataDispatcher::Delegate &)>
 Signature for constructing PointerDataDispatcher.
 
using FramePipeline = Pipeline< FrameItem >
 
using ThreadConfig = fml::Thread::ThreadConfig
 
using ThreadConfigSetter = fml::Thread::ThreadConfigSetter
 
typedef void * GPUMTLDeviceHandle
 
typedef void * GPUMTLCommandQueueHandle
 
typedef void * GPUCAMetalLayerHandle
 
typedef const void * GPUMTLTextureHandle
 
typedef void(* GPUMTLDestructionCallback) (void *)
 
template<class T >
using EGLResult = std::pair< bool, T >
 
using JavaLocalRef = std::nullptr_t
 
template<typename T >
using MessageReply = std::function< void(const T &reply)>
 
template<typename T >
using MessageHandler = std::function< void(const T &message, const MessageReply< T > &reply)>
 
typedef std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
 
typedef std::function< void(const uint8_t *message, size_t message_size, BinaryReply reply)> BinaryMessageHandler
 
using EncodableList = std::vector< EncodableValue >
 
using EncodableMap = std::map< EncodableValue, EncodableValue >
 
template<typename T >
using StreamHandlerListen = std::function< std::unique_ptr< StreamHandlerError< T > >(const T *arguments, std::unique_ptr< EventSink< T > > &&events)>
 
template<typename T >
using StreamHandlerCancel = std::function< std::unique_ptr< StreamHandlerError< T > >(const T *arguments)>
 
template<typename T >
using MethodCallHandler = std::function< void(const MethodCall< T > &call, std::unique_ptr< MethodResult< T > > result)>
 
template<typename T >
using ResultHandlerSuccess = std::function< void(const T *result)>
 
template<typename T >
using ResultHandlerError = std::function< void(const std::string &error_code, const std::string &error_message, const T *error_details)>
 
template<typename T >
using ResultHandlerNotImplemented = std::function< void()>
 
typedef std::variant< PixelBufferTexture, GpuSurfaceTextureTextureVariant
 
typedef ui::AXNode::AXID AccessibilityNodeId
 
using ProductVersion = std::tuple< int32_t, int32_t, int32_t >
 
typedef void(^ KeyboardLayoutNotifier) ()
 
using WindowProcDelegate = std::function< std::optional< LRESULT >(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)>
 
using UniqueAotDataPtr = std::unique_ptr< _FlutterEngineAOTData, FlutterEngineCollectAOTDataFnPtr >
 
using FlutterViewId = int64_t
 
typedef uint64_t(* CurrentTimeProc) ()
 
using Sampler = std::function< ProfileSample(void)>
 Sampler is run during SamplingProfiler::SampleRepeatedly. Each platform should implement its version of a Sampler if they decide to participate in gathering profiling metrics.
 

Enumerations

enum class  DisplayListOpType
 
enum class  DlBlendMode {
  kClear , kSrc , kDst , kSrcOver ,
  kDstOver , kSrcIn , kDstIn , kSrcOut ,
  kDstOut , kSrcATop , kDstATop , kXor ,
  kPlus , kModulate , kScreen , kOverlay ,
  kDarken , kLighten , kColorDodge , kColorBurn ,
  kHardLight , kSoftLight , kDifference , kExclusion ,
  kMultiply , kHue , kSaturation , kColor ,
  kLuminosity , kLastCoeffMode = kScreen , kLastSeparableMode , kLastMode = kLuminosity ,
  kDefaultMode = kSrcOver
}
 
enum class  DisplayListCompare { kUseBulkCompare , kNotEqual , kEqual }
 
enum class  DlDrawStyle {
  kFill , kStroke , kStrokeAndFill , kLastStyle = kStrokeAndFill ,
  kDefaultStyle = kFill
}
 
enum class  DlStrokeCap {
  kButt , kRound , kSquare , kLastCap = kSquare ,
  kDefaultCap = kButt
}
 
enum class  DlStrokeJoin {
  kMiter , kRound , kBevel , kLastJoin = kBevel ,
  kDefaultJoin = kMiter
}
 
enum class  DlFilterMode { kNearest , kLinear , kLast = kLinear }
 
enum class  DlImageSampling { kNearestNeighbor , kLinear , kMipmapLinear , kCubic }
 
enum class  DlTileMode { kClamp , kRepeat , kMirror , kDecal }
 
enum class  DlVertexMode { kTriangles , kTriangleStrip , kTriangleFan }
 Defines the way in which the vertices of a DlVertices object are separated into triangles into which to render. More...
 
enum class  DlColorFilterType { kBlend , kMatrix , kSrgbToLinearGamma , kLinearToSrgbGamma }
 
enum class  DlColorSourceType {
  kColor , kImage , kLinearGradient , kRadialGradient ,
  kConicalGradient , kSweepGradient , kRuntimeEffect
}
 
enum class  DlImageFilterType {
  kBlur , kDilate , kErode , kMatrix ,
  kCompose , kColorFilter , kLocalMatrix
}
 
enum class  DlMaskFilterType { kBlur }
 
enum class  DlBlurStyle { kNormal , kSolid , kOuter , kInner }
 
enum class  DlPathEffectType { kDash }
 
enum class  BoundsAccumulatorType { kRect , kRTree }
 
enum class  RasterStatus { kSuccess , kResubmit , kSkipAndRetry }
 
enum  MutatorType {
  kClipRect , kClipRRect , kClipPath , kTransform ,
  kOpacity , kBackdropFilter
}
 
enum class  PostPrerollResult { kSuccess , kResubmitFrame , kSkipAndRetryFrame }
 
enum  Clip { kNone , kHardEdge , kAntiAlias , kAntiAliasWithSaveLayer }
 
enum class  RasterCacheLayerStrategy { kLayer , kLayerChildren }
 
enum class  RasterCacheKeyType { kLayer , kDisplayList , kLayerChildren }
 
enum class  RasterCacheKeyKind { kLayerMetrics , kDisplayListMetrics }
 
enum class  ChoreographerSupportStatus { kUnsupported , kSupported32 , kSupported64 }
 
enum  ColorSpace { kSRGB , kExtendedSRGB }
 
enum  ImageByteFormat {
  kRawRGBA , kRawStraightRGBA , kRawUnmodified , kRawExtendedRgba128 ,
  kPNG
}
 
enum  MaskFilterType { kNull , kBlur }
 
enum class  SemanticsAction : int32_t {
  kTap = 1 << 0 , kLongPress = 1 << 1 , kScrollLeft = 1 << 2 , kScrollRight = 1 << 3 ,
  kScrollUp = 1 << 4 , kScrollDown = 1 << 5 , kIncrease = 1 << 6 , kDecrease = 1 << 7 ,
  kShowOnScreen = 1 << 8 , kMoveCursorForwardByCharacter = 1 << 9 , kMoveCursorBackwardByCharacter = 1 << 10 , kSetSelection = 1 << 11 ,
  kCopy = 1 << 12 , kCut = 1 << 13 , kPaste = 1 << 14 , kDidGainAccessibilityFocus = 1 << 15 ,
  kDidLoseAccessibilityFocus = 1 << 16 , kCustomAction = 1 << 17 , kDismiss = 1 << 18 , kMoveCursorForwardByWord = 1 << 19 ,
  kMoveCursorBackwardByWord = 1 << 20 , kSetText = 1 << 21
}
 
enum class  SemanticsFlags : int32_t {
  kHasCheckedState = 1 << 0 , kIsChecked = 1 << 1 , kIsSelected = 1 << 2 , kIsButton = 1 << 3 ,
  kIsTextField = 1 << 4 , kIsFocused = 1 << 5 , kHasEnabledState = 1 << 6 , kIsEnabled = 1 << 7 ,
  kIsInMutuallyExclusiveGroup = 1 << 8 , kIsHeader = 1 << 9 , kIsObscured = 1 << 10 , kScopesRoute = 1 << 11 ,
  kNamesRoute = 1 << 12 , kIsHidden = 1 << 13 , kIsImage = 1 << 14 , kIsLiveRegion = 1 << 15 ,
  kHasToggledState = 1 << 16 , kIsToggled = 1 << 17 , kHasImplicitScrolling = 1 << 18 , kIsMultiline = 1 << 19 ,
  kIsReadOnly = 1 << 20 , kIsFocusable = 1 << 21 , kIsLink = 1 << 22 , kIsSlider = 1 << 23 ,
  kIsKeyboardKey = 1 << 24 , kIsCheckStateMixed = 1 << 25 , kHasExpandedState = 1 << 26 , kIsExpanded = 1 << 27
}
 
enum class  StringAttributeType : int32_t { kSpellOut , kLocale }
 
enum class  KeyEventType : int64_t { kDown = 0 , kUp , kRepeat }
 
enum class  KeyEventDeviceType : int64_t {
  kKeyboard = 0 , kDirectionalPad , kGamepad , kJoystick ,
  kHdmi
}
 
enum class  AccessibilityFeatureFlag : int32_t {
  kAccessibleNavigation = 1 << 0 , kInvertColors = 1 << 1 , kDisableAnimations = 1 << 2 , kBoldText = 1 << 3 ,
  kReduceMotion = 1 << 4 , kHighContrast = 1 << 5 , kOnOffSwitchLabels = 1 << 6
}
 An enum for defining the different kinds of accessibility features that can be enabled by the platform. More...
 
enum  PointerButtonMouse : int64_t {
  kPointerButtonMousePrimary = 1 << 0 , kPointerButtonMouseSecondary = 1 << 1 , kPointerButtonMouseMiddle = 1 << 2 , kPointerButtonMouseBack = 1 << 3 ,
  kPointerButtonMouseForward = 1 << 4
}
 
enum  PointerButtonTouch : int64_t { kPointerButtonTouchContact = 1 << 0 }
 
enum  PointerButtonStylus : int64_t { kPointerButtonStylusContact = 1 << 0 , kPointerButtonStylusPrimary = 1 << 1 , kPointerButtonStylusSecondary = 1 << 2 }
 
enum class  IsolateLaunchType { kNewGroup , kExistingGroup }
 
enum class  TracingResult { kNotAttempted , kEnabled , kNotNecessary = kEnabled , kDisabled }
 
enum class  ContextType { kRender , kResource }
 
enum class  PipelineConsumeResult { NoneAvailable , Done , MoreAvailable }
 
enum class  DrawStatus {
  kDone , kNotSetUp , kYielded , kPipelineEmpty ,
  kGpuUnavailable
}
 
enum class  DrawSurfaceStatus { kSuccess , kRetry , kFailed , kDiscarded }
 
enum class  DartErrorCode { NoError = 0 , ApiError = 253 , CompilationError = 254 , UnknownError = 255 }
 Error exit codes for the Dart isolate. More...
 
enum class  GpuAvailability { kAvailable = 0 , kFlushAndMakeUnavailable = 1 , kUnavailable = 2 }
 Values for |Shell::SetGpuAvailability|. More...
 
enum class  MTLRenderTargetType { kMTLTexture , kCAMetalLayer }
 
enum class  AndroidEGLSurfaceMakeCurrentStatus { kSuccessAlreadyCurrent , kSuccessMadeCurrent , kFailure }
 Result of calling MakeCurrent on AndroidEGLSurface. More...
 
enum class  AndroidRenderingAPI { kSoftware , kOpenGLES , kVulkan , kAutoselect }
 
enum class  AppLifecycleState {
  kDetached , kResumed , kInactive , kHidden ,
  kPaused
}
 
enum class  PlatformProvidedMenu {
  kAbout , kQuit , kServicesSubmenu , kHide ,
  kHideOtherApplications , kShowAllApplications , kStartSpeaking , kStopSpeaking ,
  kToggleFullScreen , kMinimizeWindow , kZoomWindow , kArrangeWindowsInFront
}
 
enum class  IOSRenderingAPI { kSoftware , kMetal }
 
enum class  IOSRenderingBackend { kSkia , kImpeller }
 
enum  ModifierFlag {
  kModifierFlagControlLeft = 0x1 , kModifierFlagShiftLeft = 0x2 , kModifierFlagShiftRight = 0x4 , kModifierFlagMetaLeft = 0x8 ,
  kModifierFlagMetaRight = 0x10 , kModifierFlagAltLeft = 0x20 , kModifierFlagAltRight = 0x40 , kModifierFlagControlRight = 0x200
}
 
enum class  AppExitType { required , cancelable }
 
enum class  WindowStateEvent { kShow , kHide , kFocus , kUnfocus }
 An event representing a change in window state that may update the. More...
 

Functions

sk_sp< SkDataParseBase32 (const std::string &input)
 
sk_sp< SkDataParseBase64 (const std::string &input)
 
static void PersistentCacheStore (const fml::RefPtr< fml::TaskRunner > &worker, const std::shared_ptr< fml::UniqueFD > &cache_directory, std::string key, std::unique_ptr< fml::Mapping > value)
 
DlOpReceiverDisplayListBuilderBenchmarkAccessor (DisplayListBuilder &builder)
 
static void BM_DisplayListBuilderDefault (benchmark::State &state, DisplayListBuilderBenchmarkType type)
 
static void BM_DisplayListBuilderWithScaleAndTranslate (benchmark::State &state, DisplayListBuilderBenchmarkType type)
 
static void BM_DisplayListBuilderWithPerspective (benchmark::State &state, DisplayListBuilderBenchmarkType type)
 
static void BM_DisplayListBuilderWithClipRect (benchmark::State &state, DisplayListBuilderBenchmarkType type)
 
static void BM_DisplayListBuilderWithSaveLayer (benchmark::State &state, DisplayListBuilderBenchmarkType type)
 
static void BM_DisplayListBuilderWithSaveLayerAndImageFilter (benchmark::State &state, DisplayListBuilderBenchmarkType type)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderDefault, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderDefault, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderDefault, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderDefault, kBoundsAndRtree, DisplayListBuilderBenchmarkType::kBoundsAndRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithScaleAndTranslate, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithScaleAndTranslate, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithScaleAndTranslate, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithScaleAndTranslate, kBoundsAndRtree, DisplayListBuilderBenchmarkType::kBoundsAndRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithPerspective, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithPerspective, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithPerspective, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithPerspective, kBoundsAndRtree, DisplayListBuilderBenchmarkType::kBoundsAndRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithClipRect, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithClipRect, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithClipRect, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithClipRect, kBoundsAndRtree, DisplayListBuilderBenchmarkType::kBoundsAndRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayer, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayer, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayer, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayer, kBoundsAndRtree, DisplayListBuilderBenchmarkType::kBoundsAndRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayerAndImageFilter, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayerAndImageFilter, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayerAndImageFilter, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DisplayListBuilderWithSaveLayerAndImageFilter, kBoundsAndRtree, DisplayListBuilderBenchmarkType::kBoundsAndRtree) -> Unit(benchmark::kMicrosecond)
 
static void BM_DlRegion_FromRects (benchmark::State &state, int maxSize)
 
static void BM_SkRegion_FromRects (benchmark::State &state, int maxSize)
 
static void BM_DlRegion_GetRects (benchmark::State &state, int maxSize)
 
static void BM_SkRegion_GetRects (benchmark::State &state, int maxSize)
 
static void BM_DlRegion_Operation (benchmark::State &state, RegionOp op, bool withSingleRect, int maxSize, double sizeFactor)
 
static void BM_SkRegion_Operation (benchmark::State &state, RegionOp op, bool withSingleRect, int maxSize, double sizeFactor)
 
static void BM_DlRegion_IntersectsRegion (benchmark::State &state, int maxSize, double sizeFactor)
 
static void BM_SkRegion_IntersectsRegion (benchmark::State &state, int maxSize, double sizeFactor)
 
static void BM_DlRegion_IntersectsSingleRect (benchmark::State &state, int maxSize)
 
static void BM_SkRegion_IntersectsSingleRect (benchmark::State &state, int maxSize)
 
 Unit (benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_IntersectsRegion, TinyAsymmetric, 30, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_IntersectsRegion, TinyAsymmetric, 30, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_IntersectsRegion, SmallAsymmetric, 100, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_IntersectsRegion, SmallAsymmetric, 100, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_IntersectsRegion, MediumAsymmetric, 400, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_IntersectsRegion, MediumAsymmetric, 400, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_IntersectsRegion, LargeAsymmetric, 1500, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_IntersectsRegion, LargeAsymmetric, 1500, kSizeFactorSmall) -> Unit(benchmark::kNanosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_Tiny, RegionOp::kUnion, false, 30, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_Tiny, RegionOp::kUnion, false, 30, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_Small, RegionOp::kUnion, false, 100, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_Small, RegionOp::kUnion, false, 100, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_Medium, RegionOp::kUnion, false, 400, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_Medium, RegionOp::kUnion, false, 400, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_Large, RegionOp::kUnion, false, 1500, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_Large, RegionOp::kUnion, false, 1500, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_TinyAsymmetric, RegionOp::kUnion, false, 30, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_TinyAsymmetric, RegionOp::kUnion, false, 30, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_SmallAsymmetric, RegionOp::kUnion, false, 100, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_SmallAsymmetric, RegionOp::kUnion, false, 100, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_MediumAsymmetric, RegionOp::kUnion, false, 400, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_MediumAsymmetric, RegionOp::kUnion, false, 400, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Union_LargeAsymmetric, RegionOp::kUnion, false, 1500, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Union_LargeAsymmetric, RegionOp::kUnion, false, 1500, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_Tiny, RegionOp::kIntersection, false, 30, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_Tiny, RegionOp::kIntersection, false, 30, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_Small, RegionOp::kIntersection, false, 100, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_Small, RegionOp::kIntersection, false, 100, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_Medium, RegionOp::kIntersection, false, 400, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_Medium, RegionOp::kIntersection, false, 400, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_Large, RegionOp::kIntersection, false, 1500, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_Large, RegionOp::kIntersection, false, 1500, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_TinyAsymmetric, RegionOp::kIntersection, false, 30, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_TinyAsymmetric, RegionOp::kIntersection, false, 30, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_SmallAsymmetric, RegionOp::kIntersection, false, 100, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_SmallAsymmetric, RegionOp::kIntersection, false, 100, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_MediumAsymmetric, RegionOp::kIntersection, false, 400, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_MediumAsymmetric, RegionOp::kIntersection, false, 400, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_LargeAsymmetric, RegionOp::kIntersection, false, 1500, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_LargeAsymmetric, RegionOp::kIntersection, false, 1500, kSizeFactorSmall) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_SingleRect_Tiny, RegionOp::kIntersection, true, 30, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_SingleRect_Tiny, RegionOp::kIntersection, true, 30, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_SingleRect_Small, RegionOp::kIntersection, true, 100, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_SingleRect_Small, RegionOp::kIntersection, true, 100, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_SingleRect_Medium, RegionOp::kIntersection, true, 400, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_SingleRect_Medium, RegionOp::kIntersection, true, 400, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_DlRegion_Operation, Intersection_SingleRect_Large, RegionOp::kIntersection, true, 1500, 1.0) -> Unit(benchmark::kMicrosecond)
 
 BENCHMARK_CAPTURE (BM_SkRegion_Operation, Intersection_SingleRect_Large, RegionOp::kIntersection, true, 1500, 1.0) -> Unit(benchmark::kMicrosecond)
 
 Unit (benchmark::kMicrosecond)
 
static bool CompareOps (uint8_t *ptrA, uint8_t *endA, uint8_t *ptrB, uint8_t *endB)
 
DlOpReceiverDisplayListBuilderTestingAccessor (DisplayListBuilder &builder)
 
DlPaint DisplayListBuilderTestingAttributes (DisplayListBuilder &builder)
 
static void CopyV (void *dst)
 
template<typename S , typename... Rest>
static void CopyV (void *dst, const S *src, int n, Rest &&... rest)
 
static constexpr bool is_power_of_two (int value)
 
 DEFINE_DRAW_POINTS_OP (Points, kPoints)
 
 DEFINE_DRAW_POINTS_OP (Lines, kLines)
 
 DEFINE_DRAW_POINTS_OP (Polygon, kPolygon)
 
static void DlVerticesDeleter (void *p)
 
static size_t bytes_needed (int vertex_count, Flags flags, int index_count)
 
static SkRect compute_bounds (const SkPoint *points, int count)
 
static void store_points (char *dst, int offset, const float *src, int count)
 
static void DlGradientDeleter (void *p)
 
static void DlPathEffectDeleter (void *p)
 
SkPaint ToSk (const DlPaint &paint)
 
SkPaint ToStrokedSk (const DlPaint &paint)
 
SkPaint ToNonShaderSk (const DlPaint &paint)
 
sk_sp< SkShaderToSk (const DlColorSource *source)
 
sk_sp< SkImageFilterToSk (const DlImageFilter *filter)
 
sk_sp< SkColorFilterToSk (const DlColorFilter *filter)
 
sk_sp< SkMaskFilterToSk (const DlMaskFilter *filter)
 
sk_sp< SkPathEffectToSk (const DlPathEffect *effect)
 
sk_sp< SkVerticesToSk (const DlVertices *vertices)
 
SkBlendMode ToSk (DlBlendMode mode)
 
SkColor ToSk (DlColor color)
 
SkPaint::Style ToSk (DlDrawStyle style)
 
SkPaint::Cap ToSk (DlStrokeCap cap)
 
SkPaint::Join ToSk (DlStrokeJoin join)
 
SkTileMode ToSk (DlTileMode dl_mode)
 
SkBlurStyle ToSk (const DlBlurStyle blur_style)
 
SkFilterMode ToSk (const DlFilterMode filter_mode)
 
SkVertices::VertexMode ToSk (DlVertexMode dl_mode)
 
SkSamplingOptions ToSk (DlImageSampling sampling)
 
SkCanvas::SrcRectConstraint ToSk (DlCanvas::SrcRectConstraint constraint)
 
SkClipOp ToSk (DlCanvas::ClipOp op)
 
SkCanvas::PointMode ToSk (DlCanvas::PointMode mode)
 
sk_sp< SkShaderToSk (const std::shared_ptr< const DlColorSource > &source)
 
sk_sp< SkShaderToSk (const DlColorSource &source)
 
sk_sp< SkImageFilterToSk (const std::shared_ptr< const DlImageFilter > &filter)
 
sk_sp< SkImageFilterToSk (const DlImageFilter &filter)
 
sk_sp< SkColorFilterToSk (const std::shared_ptr< const DlColorFilter > &filter)
 
sk_sp< SkColorFilterToSk (const DlColorFilter &filter)
 
sk_sp< SkMaskFilterToSk (const std::shared_ptr< const DlMaskFilter > &filter)
 
sk_sp< SkMaskFilterToSk (const DlMaskFilter &filter)
 
sk_sp< SkPathEffectToSk (const std::shared_ptr< const DlPathEffect > &effect)
 
sk_sp< SkPathEffectToSk (const DlPathEffect &effect)
 
sk_sp< SkVerticesToSk (const std::shared_ptr< const DlVertices > &vertices)
 
sk_sp< SkVerticesToSk (const DlVertices &vertices)
 
template<class T >
bool Equals (const T *a, const T *b)
 
template<class T >
bool Equals (std::shared_ptr< const T > a, const T *b)
 
template<class T >
bool Equals (const T *a, std::shared_ptr< const T > b)
 
template<class T >
bool Equals (std::shared_ptr< const T > a, std::shared_ptr< const T > b)
 
template<class T >
bool NotEquals (const T *a, const T *b)
 
template<class T >
bool NotEquals (std::shared_ptr< const T > a, const T *b)
 
template<class T >
bool NotEquals (const T *a, std::shared_ptr< const T > b)
 
template<class T >
bool NotEquals (std::shared_ptr< const T > a, std::shared_ptr< const T > b)
 
const std::string & GetGoldenDir ()
 
void SetGoldenDir (const std::string &dir)
 
const std::string & GetFontFile ()
 
void SetFontFile (const std::string &file)
 
 TEST (FrameTimingsRecorderTest, RecordVsync)
 
 TEST (FrameTimingsRecorderTest, RecordBuildTimes)
 
 TEST (FrameTimingsRecorderTest, RecordRasterTimes)
 
 TEST (FrameTimingsRecorderTest, RecordRasterTimesWithCache)
 
 TEST (FrameTimingsRecorderTest, ThrowWhenRecordBuildBeforeVsync)
 
 TEST (FrameTimingsRecorderTest, ThrowWhenRecordRasterBeforeBuildEnd)
 
 TEST (FrameTimingsRecorderTest, RecordersHaveUniqueFrameNumbers)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameFrameNumber)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameVsyncStartAndTarget)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameBuildStart)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameBuildEnd)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameRasterStart)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameRasterEnd)
 
 TEST (FrameTimingsRecorderTest, ClonedHasSameRasterEndWithCache)
 
 TEST (FrameTimingsRecorderTest, FrameNumberTraceArgIsValid)
 
static bool safe_intersection_test (const SkRect *rect1, const SkRect &rect2)
 
static bool IsDisplayListWorthRasterizing (const DisplayList *display_list, bool will_change, bool is_complex, DisplayListComplexityCalculator *complexity_calculator)
 
bool Rasterize (RasterCacheItem::CacheState cache_state, Layer *layer, const PaintContext &paint_context, DlCanvas *canvas)
 
SkColorSpaceGetColorSpace (DlCanvas *canvas)
 
static sk_sp< SkSurfaceCreateSnapshotSurface (GrDirectContext *surface_context, const SkISize &size)
 
static sk_sp< SkDataGetRasterData (const sk_sp< SkSurface > &offscreen_surface, bool compressed)
 
void DrawCheckerboard (DlCanvas *canvas, const SkRect &rect)
 
 TEST (FlowTest, SurfaceFrameDoesNotSubmitInDtor)
 
 TEST (FlowTest, SurfaceFrameDoesNotHaveEmptyCanvas)
 
 TEST (FlowTest, SurfaceFrameDoesNotPrepareRtree)
 
 IMPLEMENT_WRAPPERTYPEINFO (flutter_gpu, FlutterGpuTestClass)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Scene)
 
static sk_sp< DlImageCreateDeferredImage (bool impeller, std::unique_ptr< LayerTree > layer_tree, fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > snapshot_delegate, fml::RefPtr< fml::TaskRunner > raster_task_runner, fml::RefPtr< SkiaUnrefQueue > unref_queue)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SceneBuilder)
 
static void PropagateIfError (Dart_Handle result)
 
static Dart_Handle InvokeFunction (Dart_Handle builtin_library, const char *name)
 
static void InitDartInternal (Dart_Handle builtin_library, bool is_ui_isolate)
 
static void InitDartCore (Dart_Handle builtin, const std::string &script_uri)
 
static void InitDartAsync (Dart_Handle builtin_library, bool is_ui_isolate)
 
static void InitDartIO (Dart_Handle builtin_library, const std::string &script_uri)
 
static std::string GetFunctionLibraryUrl (Dart_Handle closure)
 
static std::string GetFunctionClassName (Dart_Handle closure)
 
static std::string GetFunctionName (Dart_Handle func)
 
void DartPluginRegistrant_EnsureInitialized ()
 
static float SafeNarrow (double value)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Canvas)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Codec)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ColorFilter)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, EngineLayer)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, FragmentProgram)
 
static std::string RuntimeStageBackendToString (impeller::RuntimeStageBackend backend)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ReusableFragmentShader)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Gradient)
 
static SkColorType ChooseCompatibleColorType (SkColorType type)
 
static SkAlphaType ChooseCompatibleAlphaType (SkAlphaType type)
 
static std::pair< sk_sp< DlImage >, std::string > UnsafeUploadTextureToPrivate (const std::shared_ptr< impeller::Context > &context, const std::shared_ptr< impeller::DeviceBuffer > &buffer, const SkImageInfo &image_info)
 Only call this method if the GPU is available.
 
static sk_sp< SkImageResizeRasterImage (const sk_sp< SkImage > &image, const SkISize &resized_dimensions, const fml::tracing::TraceFlow &flow)
 
static sk_sp< SkImageImageFromDecompressedData (ImageDescriptor *descriptor, uint32_t target_width, uint32_t target_height, const fml::tracing::TraceFlow &flow)
 
static SkiaGPUObject< SkImageUploadRasterImage (sk_sp< SkImage > image, const fml::WeakPtr< IOManager > &io_manager, const fml::tracing::TraceFlow &flow)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImageDescriptor)
 
Dart_Handle EncodeImage (CanvasImage *canvas_image, int format, Dart_Handle callback_handle)
 
sk_sp< SkDataEncodeImage (const sk_sp< SkImage > &raster_image, ImageByteFormat format)
 
template<typename SyncSwitch >
sk_sp< SkImageConvertToRasterUsingResourceContext (const sk_sp< SkImage > &image, const fml::WeakPtr< GrDirectContext > &resource_context, const std::shared_ptr< const SyncSwitch > &is_gpu_disabled_sync_switch)
 
void ConvertImageToRasterSkia (const sk_sp< DlImage > &dl_image, std::function< void(sk_sp< SkImage >)> encode_task, const fml::RefPtr< fml::TaskRunner > &raster_task_runner, const fml::RefPtr< fml::TaskRunner > &io_task_runner, const fml::WeakPtr< GrDirectContext > &resource_context, const fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > &snapshot_delegate, const std::shared_ptr< const fml::SyncSwitch > &is_gpu_disabled_sync_switch)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImageFilter)
 
static SkImageInfo getInfoIncludingExif (SkCodec *codec)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImageShader)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImmutableBuffer)
 
SkM44 ToSkM44 (const tonic::Float64List &matrix4)
 
SkMatrix ToSkMatrix (const tonic::Float64List &matrix4)
 
tonic::Float64List ToMatrix4 (const SkMatrix &sk_matrix)
 
static void InvokeNextFrameCallback (const fml::RefPtr< CanvasImage > &image, int duration, const std::string &decode_error, std::unique_ptr< tonic::DartPersistentValue > callback, size_t trace_id)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Path)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, PathMeasure)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Picture)
 
static sk_sp< DlImageCreateDeferredImage (bool impeller, sk_sp< DisplayList > display_list, uint32_t width, uint32_t height, fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > snapshot_delegate, fml::RefPtr< fml::TaskRunner > raster_task_runner, fml::RefPtr< SkiaUnrefQueue > unref_queue)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, PictureRecorder)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SceneNode)
 
static impeller::Matrix ToMatrix (const tonic::Float64List &matrix4)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SceneShader)
 
static impeller::Matrix DefaultCameraTransform ()
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Shader)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Vertices)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SemanticsUpdate)
 
void pushStringAttributes (StringAttributes &destination, const std::vector< NativeStringAttribute * > &native_attributes)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SemanticsUpdateBuilder)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, NativeStringAttribute)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Paragraph)
 
static tonic::Float32List EncodeTextBoxes (const std::vector< txt::Paragraph::TextBox > &boxes)
 
Dart_Handle glyphInfoFrom (Dart_Handle constructor, const skia::textlayout::Paragraph::GlyphInfo &glyphInfo)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ParagraphBuilder)
 
void decodeStrut (Dart_Handle strut_data, const std::vector< std::string > &strut_font_families, txt::ParagraphStyle &paragraph_style)
 
void decodeTextShadows (Dart_Handle shadows_data, std::vector< txt::TextShadow > &decoded_shadows)
 
void decodeFontFeatures (Dart_Handle font_features_data, txt::FontFeatures &font_features)
 
void decodeFontVariations (Dart_Handle font_variations_data, txt::FontVariations &font_variations)
 
static void BM_PlatformMessageResponseDartComplete (benchmark::State &state)
 
static void BM_PathVolatilityTracker (benchmark::State &state)
 
 BENCHMARK (BM_PathVolatilityTracker) -> Unit(benchmark::kMillisecond)
 
bool operator== (const ViewportMetrics &a, const ViewportMetrics &b)
 
std::ostream & operator<< (std::ostream &os, const ViewportMetrics &a)
 
static bool InvokeMainEntrypoint (Dart_Handle user_entrypoint_function, Dart_Handle args)
 
bool InvokeDartPluginRegistrantIfAvailable (Dart_Handle library_handle)
 
bool FindAndInvokeDartPluginRegistrant ()
 
 TEST (DartServiceIsolateTest, CanAddAndRemoveHandles)
 
static std::unique_ptr< const fml::MappingGetFileMapping (const std::string &path, bool executable)
 
static std::shared_ptr< const fml::MappingSearchMapping (const MappingCallback &embedder_mapping_callback, const std::string &file_path, const std::vector< std::string > &native_library_path, const char *native_library_symbol_name, bool is_executable)
 
static std::shared_ptr< const fml::MappingResolveVMData (const Settings &settings)
 
static std::shared_ptr< const fml::MappingResolveVMInstructions (const Settings &settings)
 
static std::shared_ptr< const fml::MappingResolveIsolateData (const Settings &settings)
 
static std::shared_ptr< const fml::MappingResolveIsolateInstructions (const Settings &settings)
 
fml::TimePoint DartTimelineTicksSinceEpoch ()
 
static std::string DartFileRecorderArgs (const std::string &path)
 
static std::string DartOldGenHeapSizeArgs (uint64_t heap_size)
 
bool DartFileModifiedCallback (const char *source_url, int64_t since_ms)
 
void ThreadExitCallback ()
 
Dart_Handle GetVMServiceAssetsArchiveCallback ()
 
static bool ServiceStreamListenCallback (const char *stream_id)
 
static void ServiceStreamCancelCallback (const char *stream_id)
 
static std::vector< const char * > ProfilingFlags (bool enable_profiling)
 
void PushBackAll (std::vector< const char * > *args, const char **argv, size_t argc)
 
static void EmbedderInformationCallback (Dart_EmbedderInformation *info)
 
static std::vector< std::string > ParseKernelListPaths (std::unique_ptr< fml::Mapping > kernel_list)
 
static std::vector< std::future< std::unique_ptr< const fml::Mapping > > > PrepareKernelMappings (const std::vector< std::string > &kernel_pieces_paths, const std::shared_ptr< AssetManager > &asset_manager, const fml::RefPtr< fml::TaskRunner > &io_worker)
 
bool EnableTracingIfNecessary (const Settings &vm_settings)
 Enables tracing in the process so that JIT mode VMs may be launched. Explicitly enabling tracing is not required on all platforms. On platforms where it is not required, calling this method will return true. If tracing is required but cannot be enabled, it is the responsibility of the caller to display the appropriate error message to the user as subsequent attempts to launch the VM in JIT mode will cause process termination.
 
TracingResult GetTracingResult ()
 Returns if a tracing check has been performed and its result. To enable tracing, the Settings object used to launch the VM is required. Components may want to display messages based on the result of a previous tracing check without actually having the settings object. This accessor can be used instead.
 
static void WriteServerErrorResponse (rapidjson::Document *document, const char *message)
 
static bool HandleMessageOnHandler (ServiceProtocol::Handler *handler, std::string_view method, const ServiceProtocol::Handler::ServiceProtocolMap &params, rapidjson::Document *document)
 
static std::string CreateFlutterViewID (intptr_t handler)
 
static std::string CreateIsolateID (int64_t isolate)
 
std::vector< sk_sp< SkTypeface > > GetTestFontData ()
 
std::vector< std::string > GetTestFontFamilyNames ()
 
GrContextOptions MakeDefaultContextOptions (ContextType type, std::optional< GrBackendApi > api=std::nullopt)
 Initializes GrContextOptions with values suitable for Flutter. The options can be further tweaked before a GrContext is created from these options.
 
 TEST_F (EngineTest, Create)
 
 TEST_F (EngineTest, DispatchPlatformMessageUnknown)
 
 TEST_F (EngineTest, DispatchPlatformMessageInitialRoute)
 
 TEST_F (EngineTest, DispatchPlatformMessageInitialRouteIgnored)
 
 TEST_F (EngineTest, SpawnSharesFontLibrary)
 
 TEST_F (EngineTest, SpawnWithCustomInitialRoute)
 
 TEST_F (EngineTest, SpawnWithCustomSettings)
 
 TEST_F (EngineTest, PassesLoadDartDeferredLibraryErrorToRuntime)
 
 TEST_F (EngineTest, AnimatorSubmitWarmUpImplicitView)
 
size_t GetNextPipelineTraceID ()
 
static constexpr std::chrono::milliseconds kSkiaCleanupExpiration (15000)
 
static sk_sp< SkDataScreenshotLayerTreeAsPicture (flutter::LayerTree *tree, flutter::CompositorContext &compositor_context)
 
static void RenderFrameForScreenshot (flutter::CompositorContext &compositor_context, DlCanvas *canvas, flutter::LayerTree *tree, GrDirectContext *surface_context, const std::shared_ptr< impeller::AiksContext > &aiks_context)
 
 TEST (RasterizerTest, create)
 
static std::unique_ptr< FrameTimingsRecorderCreateFinishedBuildRecorder (fml::TimePoint timestamp)
 
static std::unique_ptr< FrameTimingsRecorderCreateFinishedBuildRecorder ()
 
 TEST (RasterizerTest, drawEmptyPipeline)
 
 TEST (RasterizerTest, drawWithExternalViewEmbedderExternalViewEmbedderSubmitFrameCalled)
 
 TEST (RasterizerTest, drawWithExternalViewEmbedderAndThreadMergerNotMergedExternalViewEmbedderSubmitFrameNotCalled)
 
 TEST (RasterizerTest, drawWithExternalViewEmbedderAndThreadsMergedExternalViewEmbedderSubmitFrameCalled)
 
 TEST (RasterizerTest, drawLastLayerTreeWithThreadsMergedExternalViewEmbedderAndEndFrameCalled)
 
 TEST (RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNoSurfaceIsSet)
 
 TEST (RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNotUsedThisFrame)
 
 TEST (RasterizerTest, externalViewEmbedderDoesntEndFrameWhenPipelineIsEmpty)
 
 TEST (RasterizerTest, drawMultipleViewsWithExternalViewEmbedder)
 
 TEST (RasterizerTest, drawWithGpuEnabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame)
 
 TEST (RasterizerTest, drawWithGpuDisabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame)
 
 TEST (RasterizerTest, drawWithGpuEnabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesAcquireFrame)
 
 TEST (RasterizerTest, drawWithGpuDisabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesntAcquireFrame)
 
 TEST (RasterizerTest, FrameTimingRecorderShouldStartRecordingRasterTimeBeforeSurfaceAcquireFrame)
 
 TEST (RasterizerTest, drawLayerTreeWithCorrectFrameTimingWhenPipelineIsMoreAvailable)
 
 TEST (RasterizerTest, TeardownFreesResourceCache)
 
 TEST (RasterizerTest, TeardownNoSurface)
 
 TEST (RasterizerTest, presentationTimeSetWhenVsyncTargetInFuture)
 
 TEST (RasterizerTest, presentationTimeNotSetWhenVsyncTargetInPast)
 
sk_sp< SkDataSerializeTypefaceWithoutData (SkTypeface *typeface, void *ctx)
 
sk_sp< SkDataSerializeTypefaceWithData (SkTypeface *typeface, void *ctx)
 
sk_sp< SkTypefaceDeserializeTypefaceWithoutData (const void *data, size_t length, void *ctx)
 
struct flutter::ImageMetaData __attribute__ ((packed))
 
sk_sp< SkDataSerializeImageWithoutData (SkImage *image, void *ctx)
 
sk_sp< SkImageDeserializeImageWithoutData (const void *data, size_t length, void *ctx)
 
static impeller::RuntimeStageBackend DetermineRuntimeStageBackend (const std::shared_ptr< impeller::Context > &impeller_context)
 
static void ServiceProtocolParameterError (rapidjson::Document *response, std::string error_details)
 
static void ServiceProtocolFailureError (rapidjson::Document *response, std::string message)
 
static rapidjson::Value SerializeLayerSnapshot (double device_pixel_ratio, const LayerSnapshotData &snapshot, rapidjson::Document *response)
 
static void StartupAndShutdownShell (benchmark::State &state, bool measure_startup, bool measure_shutdown)
 
static void BM_ShellInitialization (benchmark::State &state)
 
 BENCHMARK (BM_ShellInitialization)
 
static void BM_ShellShutdown (benchmark::State &state)
 
 BENCHMARK (BM_ShellShutdown)
 
static void BM_ShellInitializationAndShutdown (benchmark::State &state)
 
 BENCHMARK (BM_ShellInitializationAndShutdown)
 
void InitSkiaEventTracer (bool enabled, const std::optional< std::vector< std::string > > &allowlist)
 
void PrintUsage (const std::string &executable_name)
 
const std::string_view FlagForSwitch (Switch swtch)
 
static std::vector< std::string > ParseCommaDelimited (const std::string &input)
 
static bool IsAllowedDartVMFlag (const std::string &flag)
 
template<typename T >
static bool GetSwitchValue (const fml::CommandLine &command_line, Switch sw, T *result)
 
std::unique_ptr< fml::MappingGetSymbolMapping (const std::string &symbol_prefix, const std::string &native_lib_path)
 
Settings SettingsFromCommandLine (const fml::CommandLine &command_line)
 
DEF_SWITCHES_START DEF_SWITCH (AotSharedLibraryName, "aot-shared-library-name", "Name of the *.so containing AOT compiled Dart assets.") DEF_SWITCH(AotVMServiceSharedLibraryName
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate DEF_SWITCH (SnapshotAssetPath, "snapshot-asset-path", "Path to the directory containing the four files specified by " "VmSnapshotData, VmSnapshotInstructions, " "VmSnapshotInstructions and IsolateSnapshotInstructions.") DEF_SWITCH(VmSnapshotData
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present DEF_SWITCH (VmSnapshotInstructions, "vm-snapshot-instr", "The VM instructions snapshot that will be memory mapped as read " "and executable. SnapshotAssetPath must be present.") DEF_SWITCH(IsolateSnapshotData
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present DEF_SWITCH (IsolateSnapshotInstructions, "isolate-snapshot-instr", "The isolate instructions snapshot that will be memory mapped as " "read and executable. SnapshotAssetPath must be present.") DEF_SWITCH(CacheDirPath
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache DEF_SWITCH (ICUSymbolPrefix, "icu-symbol-prefix", "Prefix for the symbols representing ICU data linked into the " "Flutter library.") DEF_SWITCH(ICUNativeLibPath
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data DEF_SWITCH (DartFlags, "dart-flags", "Flags passed directly to the Dart VM without being interpreted " "by the Flutter shell.") DEF_SWITCH(DeviceVMServiceHost
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified DEF_SWITCH (DeviceObservatoryHost, "observatory-host", "(deprecated) The hostname/IP address on which the Dart VM Service should " "be served. If not set, defaults to 127.0.0.1 or ::1 depending on " "whether --ipv6 is specified.") DEF_SWITCH(DeviceVMServicePort
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port DEF_SWITCH (DeviceObservatoryPort, "observatory-port", "(deprecated) A custom Dart VM Service port. The default is to pick " "a randomly " "available open port.") DEF_SWITCH(DisableVMService
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode DEF_SWITCH (DisableObservatory, "disable-observatory", "(deprecated) Disable the Dart VM Service. The Dart VM Service is " "never available " "in release mode.") DEF_SWITCH(DisableVMServicePublication
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication DEF_SWITCH (DisableObservatoryPublication, "disable-observatory-publication", "(deprecated) Disable mDNS Dart VM Service publication.") DEF_SWITCH(IPv6
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set DEF_SWITCH (EnableDartProfiling, "enable-dart-profiling", "Enable Dart profiling. Profiling information can be viewed from " "Dart / Flutter DevTools.") DEF_SWITCH(EndlessTraceBuffer
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however DEF_SWITCH (EnableSoftwareRendering, "enable-software-rendering", "Enable rendering using the Skia software backend. This is useful " "when testing Flutter on emulators. By default, Flutter will " "attempt to either use OpenGL, Metal, or Vulkan.") DEF_SWITCH(Route
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework DEF_SWITCH (SkiaDeterministicRendering, "skia-deterministic-rendering", "Skips the call to SkGraphics::Init(), thus avoiding swapping out " "some Skia function pointers based on available CPU features. This " "is used to obtain 100% deterministic behavior in Skia rendering.") DEF_SWITCH(FlutterAssetsDir
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory DEF_SWITCH (DisableServiceAuthCodes, "disable-service-auth-codes", "Disable the requirement for authentication codes for communicating" " with the VM service.") DEF_SWITCH(EnableServicePortFallback
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails DEF_SWITCH (StartPaused, "start-paused", "Start the application paused in the Dart debugger.") DEF_SWITCH(TraceStartup
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer DEF_SWITCH (TraceSkia, "trace-skia", "Trace Skia calls. This is useful when debugging the GPU threed." "By default, Skia tracing is not enabled to reduce the number of " "traced events") DEF_SWITCH(TraceSkiaAllowlist
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list DEF_SWITCH (TraceAllowlist, "trace-allowlist", "Filters out all trace events except those that are specified in this " "comma separated list of allowed prefixes.") DEF_SWITCH(DumpSkpOnShaderCompilation
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader Automatically dump the skp that triggers new shader compilations This is useful for writing custom ShaderWarmUp to reduce jank By this is not enabled to reduce the overhead DEF_SWITCH (CacheSkSL, "cache-sksl", "Only cache the shader in SkSL instead of binary or GLSL. This " "should only be used during development phases. The generated SkSLs " "can later be used in the release build for shader precompilation " "at launch in order to eliminate the shader-compile jank.") DEF_SWITCH(PurgePersistentCache
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader Automatically dump the skp that triggers new shader compilations This is useful for writing custom ShaderWarmUp to reduce jank By this is not enabled to reduce the overhead purge persistent Remove all existing persistent cache This is mainly for debugging purposes such as reproducing the shader compilation jank DEF_SWITCH (TraceSystrace, "trace-systrace", "Trace to the system tracer (instead of the timeline) on platforms where " "such a tracer is available. Currently only supported on Android and " "Fuchsia.") DEF_SWITCH(TraceToFile
 
it will be possible to load the file into Perfetto s trace viewer DEF_SWITCH (UseTestFonts, "use-test-fonts", "Running tests that layout and measure text will not yield " "consistent results across various platforms. Enabling this option " "will make font resolution default to the Ahem test font on all " "platforms (See https://www.w3.org/Style/CSS/Test/Fonts/Ahem/). " "This option is only available on the desktop test shells.") DEF_SWITCH(DisableAssetFonts
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine DEF_SWITCH (VerboseLogging, "verbose-logging", "By default, only errors are logged. This flag enabled logging at " "all severity levels. This is NOT a per shell flag and affect log " "levels for all shells in the process.") DEF_SWITCH(RunForever
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed DEF_SWITCH (DisableDartAsserts, "disable-dart-asserts", "Dart code runs with assertions enabled when the runtime mode is " "debug. In profile and release product modes, assertions are " "disabled. This flag may be specified if the user wishes to run " "with assertions disabled in the debug product mode (i.e. with JIT " "or DBC).") DEF_SWITCH(EnableSerialGC
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities DEF_SWITCH (DisallowInsecureConnections, "disallow-insecure-connections", "By default, dart:io allows all socket connections. If this switch " "is set, all insecure connections are rejected.") DEF_SWITCH(DomainNetworkPolicy
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level DEF_SWITCH (ForceMultithreading, "force-multithreading", "Uses separate threads for the platform, UI, GPU and IO task runners. " "By default, a single thread is used for all task runners. Only available " "in the flutter_tester.") DEF_SWITCH(OldGenHeapSize
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap The size limit in megabytes for the Dart VM old gen heap space DEF_SWITCH (ResourceCacheMaxBytesThreshold, "resource-cache-max-bytes-threshold", "The max bytes threshold of resource cache, or 0 for unlimited.") DEF_SWITCH(EnableImpeller
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap The size limit in megabytes for the Dart VM old gen heap space enable Enable the Impeller renderer on supported platforms Ignored if Impeller is not supported on the platform DEF_SWITCH (ImpellerBackend, "impeller-backend", "Requests a particular Impeller backend on platforms that support " "multiple backends. (ex `opengles` or `vulkan`)") DEF_SWITCH(EnableVulkanValidation
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap The size limit in megabytes for the Dart VM old gen heap space enable Enable the Impeller renderer on supported platforms Ignored if Impeller is not supported on the platform enable vulkan Enable loading Vulkan validation layers The layers must be available to the application and loadable On non Vulkan this flag does nothing DEF_SWITCH (EnableOpenGLGPUTracing, "enable-opengl-gpu-tracing", "Enable tracing of GPU execution time when using the Impeller " "OpenGLES backend.") DEF_SWITCH(EnableVulkanGPUTracing
 
static bool IsProcResolverOpenGLES (const GPUSurfaceGLDelegate::GLProcResolver &proc_resolver)
 
static sk_sp< const GrGLInterfaceCreateGLInterface (const GPUSurfaceGLDelegate::GLProcResolver &proc_resolver)
 
static SkColorType FirstSupportedColorType (GrDirectContext *context, GrGLenum *format)
 
static sk_sp< SkSurfaceWrapOnscreenSurface (GrDirectContext *context, const SkISize &size, intptr_t fbo)
 
static std::shared_ptr< impeller::RendererCreateImpellerRenderer (std::shared_ptr< impeller::Context > context)
 
static std::shared_ptr< impeller::ContextCreateImpellerContext (const std::shared_ptr< impeller::ReactorGLES::Worker > &worker, bool enable_gpu_tracing)
 
static EGLResult< EGLContext > CreateContext (EGLDisplay display, EGLConfig config, EGLContext share=EGL_NO_CONTEXT)
 
static EGLResult< EGLConfig > ChooseEGLConfiguration (EGLDisplay display, uint8_t msaa_samples)
 
static bool TeardownContext (EGLDisplay display, EGLContext context)
 
static std::shared_ptr< impeller::ContextCreateImpellerContext (const fml::RefPtr< fml::NativeLibrary > &vulkan_dylib, bool enable_vulkan_validation, bool enable_gpu_tracing)
 
void LogLastEGLError ()
 
static void AndroidPlatformThreadConfigSetter (const fml::Thread::ThreadConfig &config)
 
static PlatformData GetDefaultPlatformData ()
 
static void PrefetchDefaultFontManager (JNIEnv *env, jclass jcaller)
 
static std::shared_ptr< flutter::AndroidContextCreateAndroidContext (bool use_software_rendering, const flutter::TaskRunners &task_runners, uint8_t msaa_samples, bool enable_impeller, const std::optional< std::string > &impeller_backend, bool enable_vulkan_validation, bool enable_opengl_gpu_tracing, bool enable_vulkan_gpu_tracing)
 
void putStringAttributesIntoBuffer (const StringAttributes &attributes, int32_t *buffer_int32, size_t &position, std::vector< std::vector< uint8_t > > &string_attribute_args)
 
jobject CreateFlutterCallbackInformation (JNIEnv *env, const std::string &callbackName, const std::string &callbackClassName, const std::string &callbackLibraryPath)
 
static jlong AttachJNI (JNIEnv *env, jclass clazz, jobject flutterJNI)
 
static void DestroyJNI (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static jobject SpawnJNI (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring jEntrypoint, jstring jLibraryUrl, jstring jInitialRoute, jobject jEntrypointArgs)
 
static void SurfaceCreated (JNIEnv *env, jobject jcaller, jlong shell_holder, jobject jsurface)
 
static void SurfaceWindowChanged (JNIEnv *env, jobject jcaller, jlong shell_holder, jobject jsurface)
 
static void SurfaceChanged (JNIEnv *env, jobject jcaller, jlong shell_holder, jint width, jint height)
 
static void SurfaceDestroyed (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static void RunBundleAndSnapshotFromLibrary (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring jBundlePath, jstring jEntrypoint, jstring jLibraryUrl, jobject jAssetManager, jobject jEntrypointArgs)
 
static jobject LookupCallbackInformation (JNIEnv *env, jobject, jlong handle)
 
static void SetViewportMetrics (JNIEnv *env, jobject jcaller, jlong shell_holder, jfloat devicePixelRatio, jint physicalWidth, jint physicalHeight, jint physicalPaddingTop, jint physicalPaddingRight, jint physicalPaddingBottom, jint physicalPaddingLeft, jint physicalViewInsetTop, jint physicalViewInsetRight, jint physicalViewInsetBottom, jint physicalViewInsetLeft, jint systemGestureInsetTop, jint systemGestureInsetRight, jint systemGestureInsetBottom, jint systemGestureInsetLeft, jint physicalTouchSlop, jintArray javaDisplayFeaturesBounds, jintArray javaDisplayFeaturesType, jintArray javaDisplayFeaturesState)
 
static void UpdateDisplayMetrics (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static jobject GetBitmap (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static void DispatchPlatformMessage (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring channel, jobject message, jint position, jint responseId)
 
static void DispatchEmptyPlatformMessage (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring channel, jint responseId)
 
static void CleanupMessageData (JNIEnv *env, jobject jcaller, jlong message_data)
 
static void DispatchPointerDataPacket (JNIEnv *env, jobject jcaller, jlong shell_holder, jobject buffer, jint position)
 
static void DispatchSemanticsAction (JNIEnv *env, jobject jcaller, jlong shell_holder, jint id, jint action, jobject args, jint args_position)
 
static void SetSemanticsEnabled (JNIEnv *env, jobject jcaller, jlong shell_holder, jboolean enabled)
 
static void SetAccessibilityFeatures (JNIEnv *env, jobject jcaller, jlong shell_holder, jint flags)
 
static jboolean GetIsSoftwareRendering (JNIEnv *env, jobject jcaller)
 
static void RegisterTexture (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id, jobject surface_texture)
 
static void RegisterImageTexture (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id, jobject image_texture_entry)
 
static void UnregisterTexture (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id)
 
static void MarkTextureFrameAvailable (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id)
 
static void ScheduleFrame (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static void InvokePlatformMessageResponseCallback (JNIEnv *env, jobject jcaller, jlong shell_holder, jint responseId, jobject message, jint position)
 
static void InvokePlatformMessageEmptyResponseCallback (JNIEnv *env, jobject jcaller, jlong shell_holder, jint responseId)
 
static void NotifyLowMemoryWarning (JNIEnv *env, jobject obj, jlong shell_holder)
 
static jboolean FlutterTextUtilsIsEmoji (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsEmojiModifier (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsEmojiModifierBase (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsVariationSelector (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsRegionalIndicator (JNIEnv *env, jobject obj, jint codePoint)
 
static void LoadLoadingUnitFailure (intptr_t loading_unit_id, const std::string &message, bool transient)
 
static void DeferredComponentInstallFailure (JNIEnv *env, jobject obj, jint jLoadingUnitId, jstring jError, jboolean jTransient)
 
static void LoadDartDeferredLibrary (JNIEnv *env, jobject obj, jlong shell_holder, jint jLoadingUnitId, jobjectArray jSearchPaths)
 
static void UpdateJavaAssetManager (JNIEnv *env, jobject obj, jlong shell_holder, jobject jAssetManager, jstring jAssetBundlePath)
 
bool RegisterApi (JNIEnv *env)
 
constexpr const char * AppLifecycleStateToString (AppLifecycleState state)
 
 TEST (BasicMessageChannelTest, Registration)
 
 TEST (BasicMessageChannelTest, Unregistration)
 
 TEST (BasicMessageChannelTest, Resize)
 
 TEST (BasicMessageChannelTest, SetWarnsOnOverflow)
 
 TEST (EncodableValueTest, Null)
 
 TEST (EncodableValueTest, Bool)
 
 TEST (EncodableValueTest, Int)
 
 TEST (EncodableValueTest, LongValue)
 
 TEST (EncodableValueTest, Long)
 
 TEST (EncodableValueTest, Double)
 
 TEST (EncodableValueTest, String)
 
 TEST (EncodableValueTest, CString)
 
 TEST (EncodableValueTest, UInt8List)
 
 TEST (EncodableValueTest, Int32List)
 
 TEST (EncodableValueTest, Int64List)
 
 TEST (EncodableValueTest, DoubleList)
 
 TEST (EncodableValueTest, List)
 
 TEST (EncodableValueTest, Map)
 
 TEST (EncodableValueTest, Comparison)
 
 TEST (EncodableValueTest, DeepCopy)
 
 TEST (EncodableValueTest, TypeIndexesCorrect)
 
 TEST (EventChannelTest, Registration)
 
 TEST (EventChannelTest, Unregistration)
 
 TEST (EventChannelTest, Cancel)
 
 TEST (EventChannelTest, ListenNotCancel)
 
 TEST (EventChannelTest, ReRegistration)
 
 TEST (EventChannelTest, HandlerOutlivesEventChannel)
 
 TEST (EventChannelTest, StreamHandlerErrorPassByValue)
 
 TEST (EventChannelTest, StreamHandlerErrorNullptr)
 
 TEST (MethodCallTest, Basic)
 
 TEST (MethodChannelTest, Registration)
 
 TEST (MethodChannelTest, Unregistration)
 
 TEST (MethodChannelTest, InvokeWithoutResponse)
 
 TEST (MethodChannelTest, InvokeWithResponse)
 
 TEST (MethodChannelTest, InvokeNotImplemented)
 
 TEST (MethodChannelTest, Resize)
 
 TEST (MethodChannelTest, SetWarnsOnOverflow)
 
 TEST (MethodChannelTest, NoHandlers)
 
 TEST (MethodChannelTest, Success)
 
 TEST (MethodChannelTest, Error)
 
 TEST (MethodChannelTest, NotImplemented)
 
 TEST (PluginRegistrarTest, PluginDestroyedBeforeRegistrar)
 
 TEST (PluginRegistrarTest, MessengerSend)
 
 TEST (PluginRegistrarTest, MessengerSetMessageHandler)
 
 TEST (PluginRegistrarTest, ManagerSameInstance)
 
 TEST (PluginRegistrarTest, ManagerDifferentInstances)
 
 TEST (PluginRegistrarTest, ManagerRemovesOnDestruction)
 
 TEST (PluginRegistrarTest, TextureRegistrarNotNull)
 
static void CheckEncodeDecode (const EncodableValue &value, const std::vector< uint8_t > &expected_encoding, const StandardCodecSerializer *serializer=nullptr, const std::function< bool(const EncodableValue &a, const EncodableValue &b)> &custom_comparator=nullptr)
 
static void CheckEncodeDecodeWithEncodePrefix (const EncodableValue &value, const std::vector< uint8_t > &expected_encoding_prefix, size_t expected_encoding_length)
 
 TEST (StandardMessageCodec, GetInstanceCachesInstance)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeNull)
 
 TEST (StandardMessageCodec, CanDecodeEmptyBytesAsNullWithoutCallingSerializer)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeTrue)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeFalse)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt32)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt64)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeDouble)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeString)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeStringWithNonAsciiCodePoint)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeStringWithNonBMPCodePoint)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeEmptyString)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeList)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeEmptyList)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeMap)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeByteArray)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt32Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt64Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeFloat32Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeFloat64Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeSimpleCustomType)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeVariableLengthCustomType)
 
 TEST (StandardMethodCodec, GetInstanceCachesInstance)
 
 TEST (StandardMethodCodec, HandlesMethodCallsWithNullArguments)
 
 TEST (StandardMethodCodec, HandlesMethodCallsWithArgument)
 
 TEST (StandardMethodCodec, HandlesSuccessEnvelopesWithNullResult)
 
 TEST (StandardMethodCodec, HandlesSuccessEnvelopesWithResult)
 
 TEST (StandardMethodCodec, HandlesErrorEnvelopesWithNulls)
 
 TEST (StandardMethodCodec, HandlesErrorEnvelopesWithDetails)
 
 TEST (StandardMethodCodec, HandlesCustomTypeArguments)
 
 TEST (TextureRegistrarTest, RegisterUnregisterTexture)
 
 TEST (TextureRegistrarTest, UnregisterInvalidTexture)
 
 TEST (TextureRegistrarTest, MarkFrameAvailableInvalidTexture)
 
std::vector< std::string > GetSwitchesFromEnvironment ()
 
 TEST (FlutterProjectBundle, SwitchesEmpty)
 
 TEST (FlutterProjectBundle, Switches)
 
 TEST (FlutterProjectBundle, SwitchesExtraValues)
 
 TEST (FlutterProjectBundle, SwitchesMissingValues)
 
 TEST (Point, SetsCoordinates)
 
 TEST (Size, SetsDimensions)
 
 TEST (Size, ClampsDimensionsPositive)
 
 TEST (Rect, SetsOriginAndSize)
 
 TEST (Rect, ReturnsLTRB)
 
 TEST (Rect, ReturnsWidthHeight)
 
 TEST (IncomingMessageDispatcher, SetHandle)
 
 TEST (IncomingMessageDispatcher, BlockInputFalse)
 
 TEST (IncomingMessageDispatcher, BlockInputTrue)
 
 TEST (JsonMessageCodec, EncodeDecode)
 
 TEST (JsonMethodCodec, HandlesMethodCallsWithNullArguments)
 
 TEST (JsonMethodCodec, HandlesMethodCallsWithArgument)
 
 TEST (JsonMethodCodec, HandlesSuccessEnvelopesWithNullResult)
 
 TEST (JsonMethodCodec, HandlesSuccessEnvelopesWithResult)
 
 TEST (JsonMethodCodec, HandlesErrorEnvelopesWithNulls)
 
 TEST (JsonMethodCodec, HandlesErrorEnvelopesWithDetails)
 
std::filesystem::path GetExecutableDirectory ()
 
 TEST (PathUtilsTest, ExecutableDirector)
 
 TEST (TextEditingDeltaTest, TestTextEditingDeltaConstructor)
 
 TEST (TextEditingDeltaTest, TestTextEditingDeltaNonTextConstructor)
 
 TEST (TextInputModel, SetText)
 
 TEST (TextInputModel, SetTextWideCharacters)
 
 TEST (TextInputModel, SetTextEmpty)
 
 TEST (TextInputModel, SetTextReplaceText)
 
 TEST (TextInputModel, SetTextResetsSelection)
 
 TEST (TextInputModel, SetSelectionStart)
 
 TEST (TextInputModel, SetSelectionComposingStart)
 
 TEST (TextInputModel, SetSelectionMiddle)
 
 TEST (TextInputModel, SetSelectionComposingMiddle)
 
 TEST (TextInputModel, SetSelectionEnd)
 
 TEST (TextInputModel, SetSelectionComposingEnd)
 
 TEST (TextInputModel, SetSelectionWthExtent)
 
 TEST (TextInputModel, SetSelectionWthExtentComposing)
 
 TEST (TextInputModel, SetSelectionReverseExtent)
 
 TEST (TextInputModel, SetSelectionReverseExtentComposing)
 
 TEST (TextInputModel, SetSelectionOutsideString)
 
 TEST (TextInputModel, SetSelectionOutsideComposingRange)
 
 TEST (TextInputModel, SetComposingRangeStart)
 
 TEST (TextInputModel, SetComposingRangeMiddle)
 
 TEST (TextInputModel, SetComposingRangeEnd)
 
 TEST (TextInputModel, SetComposingRangeWithExtent)
 
 TEST (TextInputModel, SetComposingRangeReverseExtent)
 
 TEST (TextInputModel, SetComposingRangeOutsideString)
 
 TEST (TextInputModel, CommitComposingNoTextWithNoSelection)
 
 TEST (TextInputModel, CommitComposingNoTextWithSelection)
 
 TEST (TextInputModel, CommitComposingTextWithNoSelection)
 
 TEST (TextInputModel, CommitComposingTextWithSelection)
 
 TEST (TextInputModel, UpdateComposingRemovesLastComposingCharacter)
 
 TEST (TextInputModel, UpdateSelectionWhileComposing)
 
 TEST (TextInputModel, AddCodePoint)
 
 TEST (TextInputModel, AddCodePointSelection)
 
 TEST (TextInputModel, AddCodePointReverseSelection)
 
 TEST (TextInputModel, AddCodePointSelectionWideCharacter)
 
 TEST (TextInputModel, AddCodePointReverseSelectionWideCharacter)
 
 TEST (TextInputModel, AddText)
 
 TEST (TextInputModel, AddTextSelection)
 
 TEST (TextInputModel, AddTextReverseSelection)
 
 TEST (TextInputModel, AddTextSelectionWideCharacter)
 
 TEST (TextInputModel, AddTextReverseSelectionWideCharacter)
 
 TEST (TextInputModel, DeleteStart)
 
 TEST (TextInputModel, DeleteMiddle)
 
 TEST (TextInputModel, DeleteEnd)
 
 TEST (TextInputModel, DeleteWideCharacters)
 
 TEST (TextInputModel, DeleteSelection)
 
 TEST (TextInputModel, DeleteReverseSelection)
 
 TEST (TextInputModel, DeleteStartComposing)
 
 TEST (TextInputModel, DeleteStartReverseComposing)
 
 TEST (TextInputModel, DeleteMiddleComposing)
 
 TEST (TextInputModel, DeleteMiddleReverseComposing)
 
 TEST (TextInputModel, DeleteEndComposing)
 
 TEST (TextInputModel, DeleteEndReverseComposing)
 
 TEST (TextInputModel, DeleteSurroundingAtCursor)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorComposing)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorAll)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorAllComposing)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorGreedy)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorGreedyComposing)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursor)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorComposing)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorAll)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorAllComposing)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorGreedy)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorGreedyComposing)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursor)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorComposing)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorAll)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorAllComposing)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorGreedy)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorGreedyComposing)
 
 TEST (TextInputModel, DeleteSurroundingSelection)
 
 TEST (TextInputModel, DeleteSurroundingReverseSelection)
 
 TEST (TextInputModel, BackspaceStart)
 
 TEST (TextInputModel, BackspaceMiddle)
 
 TEST (TextInputModel, BackspaceEnd)
 
 TEST (TextInputModel, BackspaceWideCharacters)
 
 TEST (TextInputModel, BackspaceSelection)
 
 TEST (TextInputModel, BackspaceReverseSelection)
 
 TEST (TextInputModel, BackspaceStartComposing)
 
 TEST (TextInputModel, BackspaceStartReverseComposing)
 
 TEST (TextInputModel, BackspaceMiddleComposing)
 
 TEST (TextInputModel, BackspaceMiddleReverseComposing)
 
 TEST (TextInputModel, BackspaceEndComposing)
 
 TEST (TextInputModel, BackspaceEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorForwardStart)
 
 TEST (TextInputModel, MoveCursorForwardMiddle)
 
 TEST (TextInputModel, MoveCursorForwardEnd)
 
 TEST (TextInputModel, MoveCursorForwardWideCharacters)
 
 TEST (TextInputModel, MoveCursorForwardSelection)
 
 TEST (TextInputModel, MoveCursorForwardReverseSelection)
 
 TEST (TextInputModel, MoveCursorForwardStartComposing)
 
 TEST (TextInputModel, MoveCursorForwardStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorForwardMiddleComposing)
 
 TEST (TextInputModel, MoveCursorForwardMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorForwardEndComposing)
 
 TEST (TextInputModel, MoveCursorForwardEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorBackStart)
 
 TEST (TextInputModel, MoveCursorBackMiddle)
 
 TEST (TextInputModel, MoveCursorBackEnd)
 
 TEST (TextInputModel, MoveCursorBackWideCharacters)
 
 TEST (TextInputModel, MoveCursorBackSelection)
 
 TEST (TextInputModel, MoveCursorBackReverseSelection)
 
 TEST (TextInputModel, MoveCursorBackStartComposing)
 
 TEST (TextInputModel, MoveCursorBackStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorBackMiddleComposing)
 
 TEST (TextInputModel, MoveCursorBackMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorBackEndComposing)
 
 TEST (TextInputModel, MoveCursorBackEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningStart)
 
 TEST (TextInputModel, SelectToBeginningStart)
 
 TEST (TextInputModel, MoveCursorToBeginningMiddle)
 
 TEST (TextInputModel, SelectToBeginningMiddle)
 
 TEST (TextInputModel, MoveCursorToBeginningEnd)
 
 TEST (TextInputModel, SelectToBeginningEnd)
 
 TEST (TextInputModel, MoveCursorToBeginningSelection)
 
 TEST (TextInputModel, SelectToBeginningSelection)
 
 TEST (TextInputModel, MoveCursorToBeginningReverseSelection)
 
 TEST (TextInputModel, SelectToBeginningReverseSelection)
 
 TEST (TextInputModel, MoveCursorToBeginningStartComposing)
 
 TEST (TextInputModel, SelectToBeginningStartComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningStartReverseComposing)
 
 TEST (TextInputModel, SelectToBeginningStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningMiddleComposing)
 
 TEST (TextInputModel, SelectToBeginningMiddleComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningMiddleReverseComposing)
 
 TEST (TextInputModel, SelectToBeginningMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningEndComposing)
 
 TEST (TextInputModel, SelectToBeginningEndComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningEndReverseComposing)
 
 TEST (TextInputModel, SelectToBeginningEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorToEndStart)
 
 TEST (TextInputModel, SelectToEndStart)
 
 TEST (TextInputModel, MoveCursorToEndMiddle)
 
 TEST (TextInputModel, SelectToEndMiddle)
 
 TEST (TextInputModel, MoveCursorToEndEnd)
 
 TEST (TextInputModel, SelectToEndEnd)
 
 TEST (TextInputModel, MoveCursorToEndSelection)
 
 TEST (TextInputModel, SelectToEndSelection)
 
 TEST (TextInputModel, MoveCursorToEndReverseSelection)
 
 TEST (TextInputModel, SelectToEndReverseSelection)
 
 TEST (TextInputModel, MoveCursorToEndStartComposing)
 
 TEST (TextInputModel, SelectToEndStartComposing)
 
 TEST (TextInputModel, MoveCursorToEndStartReverseComposing)
 
 TEST (TextInputModel, SelectToEndStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorToEndMiddleComposing)
 
 TEST (TextInputModel, SelectToEndMiddleComposing)
 
 TEST (TextInputModel, MoveCursorToEndMiddleReverseComposing)
 
 TEST (TextInputModel, SelectToEndMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorToEndEndComposing)
 
 TEST (TextInputModel, SelectToEndEndComposing)
 
 TEST (TextInputModel, MoveCursorToEndEndReverseComposing)
 
 TEST (TextInputModel, SelectToEndEndReverseComposing)
 
 TEST (TextInputModel, GetCursorOffset)
 
 TEST (TextInputModel, GetCursorOffsetSelection)
 
 TEST (TextInputModel, GetCursorOffsetReverseSelection)
 
 TEST (TextRange, TextRangeFromPositionZero)
 
 TEST (TextRange, TextRangeFromPositionNonZero)
 
 TEST (TextRange, TextRangeFromRange)
 
 TEST (TextRange, TextRangeFromReversedRange)
 
 TEST (TextRange, SetBase)
 
 TEST (TextRange, SetBaseReversed)
 
 TEST (TextRange, SetExtent)
 
 TEST (TextRange, SetExtentReversed)
 
 TEST (TextRange, SetStart)
 
 TEST (TextRange, SetStartReversed)
 
 TEST (TextRange, SetEnd)
 
 TEST (TextRange, SetEndReversed)
 
 TEST (TextRange, ContainsPreStartPosition)
 
 TEST (TextRange, ContainsStartPosition)
 
 TEST (TextRange, ContainsMiddlePosition)
 
 TEST (TextRange, ContainsEndPosition)
 
 TEST (TextRange, ContainsPostEndPosition)
 
 TEST (TextRange, ContainsPreStartPositionReversed)
 
 TEST (TextRange, ContainsStartPositionReversed)
 
 TEST (TextRange, ContainsMiddlePositionReversed)
 
 TEST (TextRange, ContainsEndPositionReversed)
 
 TEST (TextRange, ContainsPostEndPositionReversed)
 
 TEST (TextRange, ContainsRangePreStartPosition)
 
 TEST (TextRange, ContainsRangeSpanningStartPosition)
 
 TEST (TextRange, ContainsRangeStartPosition)
 
 TEST (TextRange, ContainsRangeMiddlePosition)
 
 TEST (TextRange, ContainsRangeEndPosition)
 
 TEST (TextRange, ContainsRangeSpanningEndPosition)
 
 TEST (TextRange, ContainsRangePostEndPosition)
 
 TEST (TextRange, ContainsRangePreStartPositionReversed)
 
 TEST (TextRange, ContainsRangeSpanningStartPositionReversed)
 
 TEST (TextRange, ContainsRangeStartPositionReversed)
 
 TEST (TextRange, ContainsRangeMiddlePositionReversed)
 
 TEST (TextRange, ContainsRangeSpanningEndPositionReversed)
 
 TEST (TextRange, ContainsRangeEndPositionReversed)
 
 TEST (TextRange, ContainsRangePostEndPositionReversed)
 
 TEST (TextRange, ReversedForwardRange)
 
 TEST (TextRange, ReversedCollapsedRange)
 
 TEST (TextRange, ReversedReversedRange)
 
std::optional< ProductVersionProductVersionFromSystemVersionPList ()
 
bool IsEncodedVersionLessThanOrSame (uint32_t encoded_lhs, ProductVersion rhs)
 
fml::MallocMapping CopyNSDataToMapping (NSData *data)
 
NSData * ConvertMappingToNSData (fml::MallocMapping buffer)
 
std::unique_ptr< fml::MappingConvertNSDataToMappingPtr (NSData *data)
 
NSData * CopyMappingPtrToNSData (std::unique_ptr< fml::Mapping > mapping)
 
fml::CommandLine CommandLineFromNSProcessInfo (NSProcessInfo *processInfoOrNil=nil)
 
FlutterStandardField FlutterStandardFieldForDataType (FlutterStandardDataType type)
 
FlutterStandardDataType FlutterStandardDataTypeForField (FlutterStandardField field)
 
UInt8 elementSizeForFlutterStandardDataType (FlutterStandardDataType type)
 
CATransform3D GetCATransform3DFromSkMatrix (const SkMatrix &matrix)
 
void ResetAnchor (CALayer *layer)
 
CGRect GetCGRectFromSkRect (const SkRect &clipSkRect)
 
BOOL BlurRadiusEqualToBlurRadius (CGFloat radius1, CGFloat radius2)
 
bool IsIosEmbeddedViewsPreviewEnabled ()
 
static IOSContextMetalSkiaCastToMetalContext (const std::shared_ptr< IOSContext > &context)
 
IOSRenderingAPI GetRenderingAPIForProcess (bool force_software)
 
Class GetCoreAnimationLayerClassForRenderingAPI (IOSRenderingAPI rendering_api)
 
bool operator== (const LayoutGoal &a, const LayoutGoal &b)
 
static bool ValidNumTextures (int expected, int actual)
 
static SkISize TransformedSurfaceSize (const SkISize &size, const SkMatrix &transformation)
 
static FlutterBackingStoreConfig MakeBackingStoreConfig (const SkISize &backing_store_size)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (double opacity)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (const SkRect &rect)
 
static FlutterSize VectorToSize (const SkVector &vector)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (const SkRRect &rrect)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (const SkMatrix &matrix)
 
static std::pair< bool, fml::RefPtr< EmbedderTaskRunner > > CreateEmbedderTaskRunner (const FlutterTaskRunnerDescription *description)
 Attempts to create a task runner from an embedder task runner description. The first boolean in the pair indicate whether the embedder specified an invalid task runner description. In this case, engine launch must be aborted. If the embedder did not specify any task runner, an engine managed task runner and thread must be selected instead.
 
static fml::RefPtr< fml::TaskRunnerGetCurrentThreadTaskRunner ()
 
fml::Thread::ThreadConfig MakeThreadConfig (flutter::ThreadHost::Type type, fml::Thread::ThreadPriority priority)
 
 TEST (FlutterEngineTest, CreateDestroy)
 
 TEST (FlutterEngineTest, ExplicitShutDown)
 
 TEST (FlutterEngineTest, RunloopTimeoutTranslation)
 
 TEST (FlutterViewControllerTest, CreateDestroy)
 
 TEST (FlutterWindowTest, SetSizeLimits)
 
 TEST (PluginRegistrarGlfwTest, GetView)
 
 TEST (PluginRegistrarGlfwTest, PluginDestroyedBeforeRegistrar)
 
std::vector< LanguageInfoGetPreferredLanguageInfo ()
 
std::vector< FlutterLocaleConvertToFlutterLocale (const std::vector< LanguageInfo > &languages)
 
 TEST_F (DartProjectTest, StandardProjectFormat)
 
 TEST_F (DartProjectTest, ProjectWithCustomPaths)
 
 TEST_F (DartProjectTest, DartEntrypointArguments)
 
 TEST (FlutterEngineTest, CreateDestroyWithCustomEntrypoint)
 
 TEST (FlutterEngineTest, ProcessMessages)
 
 TEST (FlutterEngineTest, ReloadFonts)
 
 TEST (FlutterEngineTest, GetMessenger)
 
 TEST (FlutterEngineTest, DartEntrypointArgs)
 
 TEST (FlutterEngineTest, SetNextFrameCallback)
 
 TEST (FlutterEngineTest, ProcessExternalWindowMessage)
 
 TEST (FlutterViewControllerTest, GetEngine)
 
 TEST (FlutterViewControllerTest, GetView)
 
 TEST (FlutterViewControllerTest, ForceRedraw)
 
 TEST (FlutterViewTest, HwndAccessPassesThrough)
 
 TEST (FlutterViewTest, GraphicsAdapterAccessPassesThrough)
 
 TEST (PluginRegistrarWindowsTest, GetView)
 
 TEST (PluginRegistrarWindowsTest, PluginDestroyedBeforeRegistrar)
 
 TEST (PluginRegistrarWindowsTest, RegisterUnregister)
 
 TEST (PluginRegistrarWindowsTest, CallsRegisteredDelegates)
 
 TEST (PluginRegistrarWindowsTest, StopsOnceHandled)
 
HCURSOR GetCursorFromBuffer (const std::vector< uint8_t > &buffer, double hot_x, double hot_y, int width, int height)
 
void GetMaskBitmaps (HBITMAP bitmap, HBITMAP &mask_bitmap)
 
UINT GetDpiForHWND (HWND hwnd)
 
UINT GetDpiForMonitor (HMONITOR monitor)
 
static void WindowsPlatformThreadPrioritySetter (FlutterThreadPriority priority)
 
std::string ConvertChar32ToUtf8 (char32_t ch)
 
static bool isEasciiPrintable (int codeUnit)
 
static uint64_t toLower (uint64_t n)
 
static uint16_t normalizeScancode (int windowsScanCode, bool extended)
 
std::u16string EncodeUtf16 (char32_t character)
 
uint32_t UndeadChar (uint32_t ch)
 
static AppExitType StringToAppExitType (const std::string &string)
 
std::vector< LanguageInfoGetPreferredLanguageInfo (const WindowsProcTable &windows_proc_table)
 
std::wstring GetPreferredLanguagesFromMUI (const WindowsProcTable &windows_proc_table)
 
std::vector< std::wstring > GetPreferredLanguages (const WindowsProcTable &windows_proc_table)
 
LanguageInfo ParseLanguageName (std::wstring language_name)
 
std::wstring GetUserTimeFormat ()
 
bool Prefer24HourTime (std::wstring time_format)
 
static int64_t NumWindowsForThread (const THREADENTRY32 &thread)
 
static void ConfigureShell (Shell *shell)
 
static void UnblockSIGPROF ()
 
int RunTester (const flutter::Settings &settings, bool run_forever, bool multithreaded)
 
EXPORTED Dart_Handle LoadLibraryFromKernel (const char *path)
 
EXPORTED Dart_Handle LookupEntryPoint (const char *uri, const char *name)
 
EXPORTED void Spawn (const char *entrypoint, const char *route)
 
const char * GetFlutterEngineVersion ()
 
const char * GetSkiaVersion ()
 
const char * GetDartVersion ()
 
SkPathCreatePath (SkPathFillType fill_type)
 
void DestroyPath (SkPath *path)
 
void MoveTo (SkPath *path, SkScalar x, SkScalar y)
 
void LineTo (SkPath *path, SkScalar x, SkScalar y)
 
void CubicTo (SkPath *path, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
 
void Close (SkPath *path)
 
void Reset (SkPath *path)
 
void Op (SkPath *one, SkPath *two, SkPathOp op)
 
int GetFillType (SkPath *path)
 
struct PathDataData (SkPath *path)
 
void DestroyData (PathData *data)
 
API void DestroyPathBuilder (SkPath *path)
 

Variables

constexpr double kMegaByteSizeInBytes = (1 << 20)
 
constexpr int64_t kFlutterImplicitViewId = 0
 
const double kSizeFactorSmall = 0.3
 
const int kBinarySearchThreshold = 10
 
constexpr float kInvertColorMatrix [20]
 
constexpr float kImpellerRepaintRatio = 0.7f
 The max ratio of pixel width or height to size that is dirty which results in a partial repaint.
 
static std::string gGoldenDir
 
static std::string gFontFile
 
static const auto * flow_type = "RasterCacheFlow::DisplayList"
 
static constexpr SkRect kGiantRect = SkRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F)
 
static const auto * flow_type = "RasterCacheFlow::Layer"
 
const int kDisplayRasterizerStatistics = 1 << 0
 
const int kVisualizeRasterizerStatistics = 1 << 1
 
const int kDisplayEngineStatistics = 1 << 2
 
const int kVisualizeEngineStatistics = 1 << 3
 
static const size_t kMaxSamples = 120
 
static const size_t kMaxSamples = 120
 
static const size_t kMaxFrameMarkers = 8
 
static const size_t kMaxSamples = 120
 
static const size_t kMaxFrameMarkers = 8
 
static const tonic::DartWrapperInfo kDartWrapperInfoUIImage ("ui", "_Image")
 
static constexpr bool kShouldUseMallocDeviceBuffer = false
 
static const std::array< DlImageSampling, 4 > kFilterQualities
 
static const int kSkMatrixIndexToMatrix4Index []
 
constexpr int kIsAntiAliasIndex = 0
 
constexpr int kColorIndex = 1
 
constexpr int kBlendModeIndex = 2
 
constexpr int kStyleIndex = 3
 
constexpr int kStrokeWidthIndex = 4
 
constexpr int kStrokeCapIndex = 5
 
constexpr int kStrokeJoinIndex = 6
 
constexpr int kStrokeMiterLimitIndex = 7
 
constexpr int kFilterQualityIndex = 8
 
constexpr int kMaskFilterIndex = 9
 
constexpr int kMaskFilterBlurStyleIndex = 10
 
constexpr int kMaskFilterSigmaIndex = 11
 
constexpr int kInvertColorIndex = 12
 
constexpr size_t kDataByteCount = 52
 
constexpr int kShaderIndex = 0
 
constexpr int kColorFilterIndex = 1
 
constexpr int kImageFilterIndex = 2
 
constexpr int kObjectCount = 3
 
constexpr uint32_t kColorDefault = 0xFF000000
 
constexpr uint32_t kBlendModeDefault
 
constexpr float kStrokeMiterLimitDefault = 4.0f
 
static const char * kHandleKey = "handle"
 
static const char * kRepresentationKey = "representation"
 
static const char * kNameKey = "name"
 
static const char * kClassNameKey = "class_name"
 
static const char * kLibraryPathKey = "library_path"
 
static const char * kCacheName = "flutter_callback_cache.json"
 
constexpr int32_t kMinPlatformViewId = -1
 
const int kVerticalScrollSemanticsActions
 
const int kHorizontalScrollSemanticsActions
 
const int kScrollableSemanticsActions
 
const int kScrollableSemanticsFlags
 
static constexpr int kKeyDataFieldCount = 6
 
static constexpr int kBytesPerKeyField = sizeof(int64_t)
 
static constexpr int kPointerDataFieldCount = 36
 
static constexpr int kBytesPerField = sizeof(int64_t)
 
const char * dart_plugin_registrant_library_override = nullptr
 
static const char * kDartAllConfigsArgs []
 
static const char * kDartPrecompilationArgs [] = {"--precompilation"}
 
static const char * kSerialGCArgs []
 
static FML_ALLOW_UNUSED_TYPE const char * kDartWriteProtectCodeArgs []
 
static FML_ALLOW_UNUSED_TYPE const char * kDartDisableIntegerDivisionArgs []
 
static const char * kDartAssertArgs []
 
static const char * kDartStartPausedArgs []
 
static const char * kDartEndlessTraceBufferArgs []
 
static const char * kDartSystraceTraceBufferArgs []
 
static FML_ALLOW_UNUSED_TYPE const char * kDartDefaultTraceStreamsArgs []
 
static const char * kDartStartupTraceStreamsArgs []
 
static const char * kDartSystraceTraceStreamsArgs []
 
constexpr char kFileUriPrefix [] = "file://"
 
constexpr size_t kFileUriPrefixLength = sizeof(kFileUriPrefix) - 1
 
static const char kStdoutStreamId [] = "Stdout"
 
static const char kStderrStreamId [] = "Stderr"
 
static std::atomic_size_t gVMLaunchCount
 
static std::mutex gVMMutex
 
static std::weak_ptr< DartVMgVM
 
static std::shared_ptr< DartVM > * gVMLeak
 
static std::mutex gVMDependentsMutex
 
static std::weak_ptr< const DartVMDatagVMData
 
static std::weak_ptr< ServiceProtocolgVMServiceProtocol
 
static std::weak_ptr< IsolateNameServergVMIsolateNameServer
 
static constexpr std::string_view kViewIdPrefx = "_flutterView/"
 
static constexpr std::string_view kListViewsExtensionName
 
static constexpr double kUnknownDisplayRefreshRate = 0
 To be used when the display refresh rate is unknown.
 
static constexpr char kAssetChannel [] = "flutter/assets"
 
static constexpr char kLifecycleChannel [] = "flutter/lifecycle"
 
static constexpr char kNavigationChannel [] = "flutter/navigation"
 
static constexpr char kLocalizationChannel [] = "flutter/localization"
 
static constexpr char kSettingsChannel [] = "flutter/settings"
 
static constexpr char kIsolateChannel [] = "flutter/isolate"
 
constexpr char kSkiaChannel [] = "flutter/skia"
 
constexpr char kSystemChannel [] = "flutter/system"
 
constexpr char kTypeKey [] = "type"
 
constexpr char kFontChange [] = "fontsChange"
 
DEF_SWITCHES_START aot vmservice shared library name
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot data
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder h
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service host
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not set
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service port
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm service
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service publication
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication ipv6
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace buffer
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For example
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however route
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets dir
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port fallback
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace startup
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia allowlist
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader compilation
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader Automatically dump the skp that triggers new shader compilations This is useful for writing custom ShaderWarmUp to reduce jank By default
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader Automatically dump the skp that triggers new shader compilations This is useful for writing custom ShaderWarmUp to reduce jank By this is not enabled to reduce the overhead purge persistent cache
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader Automatically dump the skp that triggers new shader compilations This is useful for writing custom ShaderWarmUp to reduce jank By this is not enabled to reduce the overhead purge persistent Remove all existing persistent cache This is mainly for debugging purposes such as reproducing the shader compilation jank trace to file
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however Start app with an specific route defined on the framework flutter assets Path to the Flutter assets directory enable service port Allow the VM service to fallback to automatic port selection if binding to a specified port fails trace Trace early application lifecycle Automatically switches to an endless trace buffer trace skia Filters out all Skia trace event categories except those that are specified in this comma separated list dump skp on shader Automatically dump the skp that triggers new shader compilations This is useful for writing custom ShaderWarmUp to reduce jank By this is not enabled to reduce the overhead purge persistent Remove all existing persistent cache This is mainly for debugging purposes such as reproducing the shader compilation jank trace to Write the timeline trace to a file at the specified path The file will be in Perfetto s proto format
 
it will be possible to load the file into Perfetto s trace viewer disable asset fonts
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via dart
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font manager
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run forever
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive mode
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial gc
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core counts
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network policy
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap The size limit in megabytes for the Dart VM old gen heap space enable impeller
 
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at