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	AccessibilityPlugin
class	AccumulationRect
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	BackingStoreLayer
struct	Base64
class	BasicMessageChannel
class	BinaryMessenger
class	BinaryMessengerImpl
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
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	DisplayListMatrixClipState
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	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	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	DrawDashedLineOp
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	EmbedderSurfaceGLImpeller
class	EmbedderSurfaceGLSkia
class	EmbedderSurfaceMetalImpeller
class	EmbedderSurfaceMetalSkia
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	GTestActivity
	A native activity subclass an in implementation of flutter::NativeActivityMain that return it. 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	LocaleStringAttribute
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	MockPlatformViewManager
class	MultiFrameCodec
class	Mutator
class	MutatorsStack
class	NativeActivity
	An instance of a native activity. Users of the native_activity_apk are meant to subclass this and return an instance of this subclass from flutter::NativeActivityMain. More...
class	NativeStringAttribute
	The peer class for all of the StringAttribute subclasses in semantics.dart. More...
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	PlatformIsolateManager
class	PlatformIsolateNativeApi
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
	Represents a platform view layer, including all mutations. More...
class	PlatformViewManager
class	PlatformViewPlugin
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	RefCountedDartWrappable
class	ResourceCacheLimitCalculator
class	ResourceCacheLimitItem
struct	RestoreOp
class	ReusableFragmentShader
struct	RotateOp
class	RRect
class	RTree
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	SaveLayerBackdropOp
class	SaveLayerEntry
struct	SaveLayerOp
struct	SaveLayerOpBase
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	DlScalar = impeller::Scalar
using	DlDegrees = impeller::Degrees
using	DlRadians = impeller::Radians
using	DlPoint = impeller::Point
using	DlIPoint = impeller::IPoint32
using	DlSize = impeller::Size
using	DlISize = impeller::ISize32
using	DlRect = impeller::Rect
using	DlIRect = impeller::IRect32
using	DlMatrix = impeller::Matrix
using	PaintRegionMap = std::map< uint64_t, PaintRegion >
using	MutatorContext = LayerStateStack::MutatorContext
using	SkiaUnrefQueue = UnrefQueue< GrDirectContext >
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. More...
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. More...
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	HardwareBufferKey = uint64_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, GpuSurfaceTexture >	TextureVariant
typedef ui::AXNode::AXID	AccessibilityNodeId
using	ProductVersion = std::tuple< int32_t, int32_t, int32_t >
using	LayerVariant = std::variant< PlatformViewLayer, BackingStoreLayer >
typedef void(^	KeyboardLayoutNotifier) ()
using	FlutterViewId = int64_t
using	WindowProcDelegate = std::function< std::optional< LRESULT >(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)>
using	UniqueAotDataPtr = std::unique_ptr< _FlutterEngineAOTData, FlutterEngineCollectAOTDataFnPtr >
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. More...

Enumerations
enum class	AndroidRenderingAPI { kSoftware , kImpellerOpenGLES , kImpellerVulkan , kSkiaOpenGLES }
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	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	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 , kFocus = 1 << 22 }
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	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	FocusChangeDirection { kProgrammatic , kForward , kBackward }
enum class	WindowStateEvent { kShow , kHide , kFocus , kUnfocus }
	An event representing a change in window state that may update the. More...

Functions
sk_sp< SkData >	ParseBase32 (const std::string &input)
sk_sp< SkData >	ParseBase64 (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)
DlOpReceiver &	DisplayListBuilderBenchmarkAccessor (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_DisplayListBuilderWithGlobalSaveLayer (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_DisplayListBuilderWithGlobalSaveLayer, kDefault, DisplayListBuilderBenchmarkType::kDefault) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListBuilderWithGlobalSaveLayer, kBounds, DisplayListBuilderBenchmarkType::kBounds) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListBuilderWithGlobalSaveLayer, kRtree, DisplayListBuilderBenchmarkType::kRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListBuilderWithGlobalSaveLayer, 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 void	BM_AdapterDispatchOverhead (benchmark::State &state, AdapterType type)
static void	BM_SetIdentity (benchmark::State &state, AdapterType type)
static void	BM_SetPerspective (benchmark::State &state, AdapterType type)
static void	BM_Translate (benchmark::State &state, AdapterType type, float tx, float ty)
static void	BM_Scale (benchmark::State &state, AdapterType type, float scale)
static void	BM_Rotate (benchmark::State &state, AdapterType type, float radians)
static void	BM_Concat (benchmark::State &state, AdapterType type, const SetupFunction &a_setup, const SetupFunction &b_setup)
static void	BM_TransformPoint (benchmark::State &state, AdapterType type, const SetupFunction &setup)
static void	BM_TransformPoints (benchmark::State &state, AdapterType type, const SetupFunction &setup)
static void	BM_TransformRectFast (benchmark::State &state, AdapterType type, const SetupFunction &setup)
static void	BM_TransformAndClipRect (benchmark::State &state, AdapterType type, const SetupFunction &setup)
static void	BM_InvertUnchecked (benchmark::State &state, AdapterType type, const SetupFunction &setup)
static void	BM_InvertAndCheck (benchmark::State &state, AdapterType type, const SetupFunction &setup)
	BENCHMARK_CAPTURE_ALL (BM_AdapterDispatchOverhead)
	BENCHMARK_CAPTURE_ALL (BM_SetIdentity)
	BENCHMARK_CAPTURE_ALL (BM_SetPerspective)
	BENCHMARK_CAPTURE_ALL_ARGS (BM_Translate, 10.0f, 15.0f)
	BENCHMARK_CAPTURE_ALL_ARGS (BM_Scale, 2.0f)
	BENCHMARK_CAPTURE_ALL_ARGS (BM_Rotate, kPiOver4)
	BENCHMARK_CAPTURE_ALL_SETUP2 (BM_Concat, Scale, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP2 (BM_Concat, ScaleTranslate, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP2 (BM_Concat, ScaleTranslate, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP2 (BM_Concat, ScaleTranslate, Perspective)
	BENCHMARK_CAPTURE_ALL_SETUP2 (BM_Concat, Perspective, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertUnchecked, Identity)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertUnchecked, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertUnchecked, Scale)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertUnchecked, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertUnchecked, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertUnchecked, Perspective)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertAndCheck, Identity)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertAndCheck, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertAndCheck, Scale)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertAndCheck, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertAndCheck, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_InvertAndCheck, Perspective)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoint, Identity)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoint, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoint, Scale)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoint, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoint, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoint, Perspective)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoints, Identity)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoints, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoints, Scale)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoints, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoints, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformPoints, Perspective)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, Identity)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, Scale)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, PerspectiveClipNone)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, PerspectiveClipOne)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, PerspectiveClipTwo)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, PerspectiveClipThree)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformRectFast, PerspectiveClipFour)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, Identity)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, Translate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, Scale)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, ScaleTranslate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, Rotate)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, PerspectiveClipNone)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, PerspectiveClipOne)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, PerspectiveClipTwo)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, PerspectiveClipThree)
	BENCHMARK_CAPTURE_ALL_SETUP (BM_TransformAndClipRect, PerspectiveClipFour)
static bool	CompareOps (const uint8_t *ptrA, const uint8_t *endA, const uint8_t *ptrB, const uint8_t *endB)
DlOpReceiver &	DisplayListBuilderTestingAccessor (DisplayListBuilder &builder)
DlPaint	DisplayListBuilderTestingAttributes (DisplayListBuilder &builder)
int	DisplayListBuilderTestingLastOpIndex (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)
static const DlRect &	ProtectEmpty (const SkRect &rect)
	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)
const DlPoint &	ToDlPoint (const SkPoint &point)
const DlRect &	ToDlRect (const SkRect &rect)
const DlISize &	ToDlISize (const SkISize &size)
constexpr DlMatrix	ToDlMatrix (const SkMatrix &matrix)
constexpr DlMatrix	ToDlMatrix (const SkM44 &matrix)
const SkPoint &	ToSkPoint (const DlPoint &point)
const SkRect &	ToSkRect (const DlRect &rect)
const SkISize &	ToSkISize (const DlISize &size)
constexpr SkMatrix	ToSkMatrix (const DlMatrix &matrix)
constexpr SkM44	ToSkM44 (const DlMatrix &matrix)
SkPaint	ToSk (const DlPaint &paint)
SkPaint	ToStrokedSk (const DlPaint &paint)
SkPaint	ToNonShaderSk (const DlPaint &paint)
sk_sp< SkShader >	ToSk (const DlColorSource *source)
sk_sp< SkImageFilter >	ToSk (const DlImageFilter *filter)
sk_sp< SkColorFilter >	ToSk (const DlColorFilter *filter)
sk_sp< SkMaskFilter >	ToSk (const DlMaskFilter *filter)
sk_sp< SkVertices >	ToSk (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< SkShader >	ToSk (const std::shared_ptr< const DlColorSource > &source)
sk_sp< SkShader >	ToSk (const DlColorSource &source)
sk_sp< SkImageFilter >	ToSk (const std::shared_ptr< const DlImageFilter > &filter)
sk_sp< SkImageFilter >	ToSk (const DlImageFilter &filter)
sk_sp< SkColorFilter >	ToSk (const std::shared_ptr< const DlColorFilter > &filter)
sk_sp< SkColorFilter >	ToSk (const DlColorFilter &filter)
sk_sp< SkMaskFilter >	ToSk (const std::shared_ptr< const DlMaskFilter > &filter)
sk_sp< SkMaskFilter >	ToSk (const DlMaskFilter &filter)
sk_sp< SkVertices >	ToSk (const std::shared_ptr< const DlVertices > &vertices)
sk_sp< SkVertices >	ToSk (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)
static const DlRect &	ProtectEmpty (const SkRect &rect)
static const DlRect &	ProtectEmpty (const DlRect &rect)
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)
SkColorSpace *	GetColorSpace (DlCanvas *canvas)
static sk_sp< SkSurface >	CreateSnapshotSurface (GrDirectContext *surface_context, const SkISize &size)
static sk_sp< SkData >	GetRasterData (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< DlImage >	CreateDeferredImage (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. More...
static sk_sp< SkImage >	ResizeRasterImage (const sk_sp< SkImage > &image, const SkISize &resized_dimensions, const fml::tracing::TraceFlow &flow)
static sk_sp< SkImage >	ImageFromDecompressedData (ImageDescriptor *descriptor, uint32_t target_width, uint32_t target_height, const fml::tracing::TraceFlow &flow)
static SkiaGPUObject< SkImage >	UploadRasterImage (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)
fml::StatusOr< sk_sp< SkData > >	EncodeImage (const sk_sp< SkImage > &raster_image, ImageByteFormat format)
template<typename SyncSwitch >
sk_sp< SkImage >	ConvertToRasterUsingResourceContext (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< DlImage >	CreateDeferredImage (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)
static void *	NativeAssetsDlopenRelative (const char *path, char **error)
static void	InitDartFFIForIsolateGroup ()
bool	InvokeDartPluginRegistrantIfAvailable (Dart_Handle library_handle)
bool	FindAndInvokeDartPluginRegistrant ()
	TEST (DartServiceIsolateTest, CanAddAndRemoveHandles)
static std::unique_ptr< const fml::Mapping >	GetFileMapping (const std::string &path, bool executable)
static std::shared_ptr< const fml::Mapping >	SearchMapping (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::Mapping >	ResolveVMData (const Settings &settings)
static std::shared_ptr< const fml::Mapping >	ResolveVMInstructions (const Settings &settings)
static std::shared_ptr< const fml::Mapping >	ResolveIsolateData (const Settings &settings)
static std::shared_ptr< const fml::Mapping >	ResolveIsolateInstructions (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. More...
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. More...
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. More...
	TEST_F (EngineAnimatorTest, AnimatorAcceptsMultipleRenders)
	TEST_F (EngineAnimatorTest, IgnoresOutOfFrameRenders)
	TEST_F (EngineAnimatorTest, IgnoresDuplicateRenders)
	TEST_F (EngineAnimatorTest, AnimatorSubmitsImplicitViewBeforeDrawFrameEnds)
	TEST_F (EngineAnimatorTest, AnimatorSubmitWarmUpImplicitView)
	TEST_F (EngineAnimatorTest, AnimatorSubmitPartialViewsForWarmUp)
	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, SpawnedEngineInheritsAssetManager)
	TEST_F (EngineTest, UpdateAssetManagerWithEqualManagers)
size_t	GetNextPipelineTraceID ()
static constexpr std::chrono::milliseconds	kSkiaCleanupExpiration (15000)
static sk_sp< SkData >	ScreenshotLayerTreeAsPicture (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< FrameTimingsRecorder >	CreateFinishedBuildRecorder (fml::TimePoint timestamp)
static std::unique_ptr< FrameTimingsRecorder >	CreateFinishedBuildRecorder ()
	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< SkData >	SerializeTypefaceWithoutData (SkTypeface *typeface, void *ctx)
sk_sp< SkData >	SerializeTypefaceWithData (SkTypeface *typeface, void *ctx)
sk_sp< SkTypeface >	DeserializeTypefaceWithoutData (const void *data, size_t length, void *ctx)
struct flutter::ImageMetaData	__attribute__ ((packed))
sk_sp< SkData >	SerializeImageWithoutData (SkImage *image, void *ctx)
sk_sp< SkImage >	DeserializeImageWithoutData (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::Mapping >	GetSymbolMapping (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 GrGLInterface >	CreateGLInterface (const GPUSurfaceGLDelegate::GLProcResolver &proc_resolver)
static SkColorType	FirstSupportedColorType (GrDirectContext *context, GrGLenum *format)
static sk_sp< SkSurface >	WrapOnscreenSurface (GrDirectContext *context, const SkISize &size, intptr_t fbo)
static std::shared_ptr< impeller::Renderer >	CreateImpellerRenderer (std::shared_ptr< impeller::Context > context)
static std::shared_ptr< impeller::Context >	CreateImpellerContext (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)
static bool	TeardownContext (EGLDisplay display, EGLContext context)
static std::shared_ptr< impeller::Context >	CreateImpellerContext (const fml::RefPtr< fml::NativeLibrary > &vulkan_dylib, bool enable_vulkan_validation, bool enable_gpu_tracing, bool quiet)
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::AndroidContext >	CreateAndroidContext (bool use_software_rendering, const flutter::TaskRunners &task_runners, AndroidRenderingAPI android_rendering_api, 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< ProductVersion >	ProductVersionFromSystemVersionPList ()
bool	IsEncodedVersionLessThanOrSame (uint32_t encoded_lhs, ProductVersion rhs)
fml::MallocMapping	CopyNSDataToMapping (NSData *data)
NSData *	ConvertMappingToNSData (fml::MallocMapping buffer)
std::unique_ptr< fml::Mapping >	ConvertNSDataToMappingPtr (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 IOSContextMetalSkia *	CastToMetalContext (const std::shared_ptr< IOSContext > &context) __attribute__((cf_audited_transfer))
IOSRenderingAPI	GetRenderingAPIForProcess (bool force_software)
Class	GetCoreAnimationLayerClassForRenderingAPI (IOSRenderingAPI rendering_api)
bool	ShouldUseMetalRenderer ()
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 (int64_t view_id, const SkISize &backing_store_size)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (double opacity)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (const SkRect &rect)
static FlutterSize	VectorToSize (const SkVector &vector)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (const SkRRect &rrect)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (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. More...
static fml::RefPtr< fml::TaskRunner >	GetCurrentThreadTaskRunner ()
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< LanguageInfo >	GetPreferredLanguageInfo ()
std::vector< FlutterLocale >	ConvertToFlutterLocale (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, GetViewId)
	TEST (FlutterViewControllerTest, GetEngine)
	TEST (FlutterViewControllerTest, GetView)
	TEST (FlutterViewControllerTest, ForceRedraw)
	TEST (FlutterViewTest, HwndAccessPassesThrough)
	TEST (FlutterViewTest, GraphicsAdapterAccessPassesThrough)
	TEST (PluginRegistrarWindowsTest, GetView)
	TEST (PluginRegistrarWindowsTest, GetViewById)
	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< LanguageInfo >	GetPreferredLanguageInfo (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)
	TEST (SamplingProfilerTest, DeleteAfterStart)
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)
EXPORTED void	ForceShutdownIsolate ()
const char *	GetFlutterEngineVersion ()
const char *	GetSkiaVersion ()
const char *	GetDartVersion ()
static void	StartTestSuite (const impeller::android::NativeWindow &window)
std::unique_ptr< NativeActivity >	NativeActivityMain (ANativeActivity *activity, std::unique_ptr< fml::Mapping > saved_state)
SkPath *	CreatePath (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 PathData *	Data (SkPath *path)
void	DestroyData (PathData *data)
API void	DestroyPathBuilder (SkPath *path)
bool	TemplaterMain (const fml::CommandLine &command_line)

Variables
constexpr double	kMegaByteSizeInBytes = (1 << 20)
constexpr int64_t	kFlutterImplicitViewId = 0
const double	kSizeFactorSmall = 0.3
static constexpr DlRect	kEmpty = DlRect()
const int	kBinarySearchThreshold = 10
constexpr float	kInvertColorMatrix [20]
static constexpr DlRect	kEmpty = DlRect()
constexpr float	kImpellerRepaintRatio = 0.7f
	The max ratio of pixel width or height to size that is dirty which results in a partial repaint. More...
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 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 constexpr size_t	kMinCount = 2
static constexpr size_t	kMaxCount = 4
static std::mutex	gVMMutex
static std::weak_ptr< DartVM >	gVM
static std::shared_ptr< DartVM > *	gVMLeak
static std::mutex	gVMDependentsMutex
static std::weak_ptr< const DartVMData >	gVMData
static std::weak_ptr< ServiceProtocol >	gVMServiceProtocol
static std::weak_ptr< IsolateNameServer >	gVMIsolateNameServer
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. More...
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 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	validation
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	backends
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 enable vulkan gpu	tracing
static constexpr const char *	kVsyncFlowName = "VsyncFlow"
static constexpr const char *	kVsyncTraceName = "VsyncProcessCallback"
static const size_t	kGrCacheMaxByteSize = 24 * (1 << 20)
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_flutter_jni_class = nullptr
static jmethodID	g_decode_image_method = nullptr
constexpr int	kMinimumAndroidApiLevelForVulkan = 29
const uint8_t	kPlatformStrongDill []
const intptr_t	kPlatformStrongDillSize
static std::unique_ptr< FlutterMain >	g_flutter_main
static constexpr size_t	kImageReaderSwapchainSize = 6u
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_flutter_callback_info_class
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_flutter_jni_class = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_java_weak_reference_class
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_texture_wrapper_class = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_image_consumer_texture_registry_interface = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_image_class = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_hardware_buffer_class = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_java_long_class = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_bitmap_class = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_bitmap_config_class = nullptr
static jmethodID	g_flutter_callback_info_constructor = nullptr
static jfieldID	g_jni_shell_holder_field = nullptr
static jmethodID	g_jni_constructor = nullptr
static jmethodID	g_long_constructor = nullptr
static jmethodID	g_handle_platform_message_method = nullptr
static jmethodID	g_handle_platform_message_response_method = nullptr
static jmethodID	g_update_semantics_method = nullptr
static jmethodID	g_update_custom_accessibility_actions_method = nullptr
static jmethodID	g_get_scaled_font_size_method = nullptr
static jmethodID	g_on_first_frame_method = nullptr
static jmethodID	g_on_engine_restart_method = nullptr
static jmethodID	g_create_overlay_surface_method = nullptr
static jmethodID	g_destroy_overlay_surfaces_method = nullptr
static jmethodID	g_on_begin_frame_method = nullptr
static jmethodID	g_on_end_frame_method = nullptr
static jmethodID	g_java_weak_reference_get_method = nullptr
static jmethodID	g_attach_to_gl_context_method = nullptr
static jmethodID	g_surface_texture_wrapper_should_update = nullptr
static jmethodID	g_update_tex_image_method = nullptr
static jmethodID	g_get_transform_matrix_method = nullptr
static jmethodID	g_detach_from_gl_context_method = nullptr
static jmethodID	g_acquire_latest_image_method = nullptr
static jmethodID	g_image_get_hardware_buffer_method = nullptr
static jmethodID	g_image_close_method = nullptr
static jmethodID	g_hardware_buffer_close_method = nullptr
static jmethodID	g_compute_platform_resolved_locale_method = nullptr
static jmethodID	g_request_dart_deferred_library_method = nullptr
static jmethodID	g_on_display_platform_view_method = nullptr
static jmethodID	g_on_display_overlay_surface_method = nullptr
static jmethodID	g_overlay_surface_id_method = nullptr
static jmethodID	g_overlay_surface_surface_method = nullptr
static jmethodID	g_bitmap_create_bitmap_method = nullptr
static jmethodID	g_bitmap_copy_pixels_from_buffer_method = nullptr
static jmethodID	g_bitmap_config_value_of = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_mutators_stack_class = nullptr
static jmethodID	g_mutators_stack_init_method = nullptr
static jmethodID	g_mutators_stack_push_transform_method = nullptr
static jmethodID	g_mutators_stack_push_cliprect_method = nullptr
static jmethodID	g_mutators_stack_push_cliprrect_method = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_vsync_waiter_class = nullptr
static jmethodID	g_async_wait_for_vsync_method_ = nullptr
static std::atomic_uint	g_refresh_rate_ = 60
constexpr int	kHasScrollingAction
const char *const	kOrientationUpdateNotificationName
const char *const	kOrientationUpdateNotificationKey
const char *const	kOverlayStyleUpdateNotificationName
const char *const	kOverlayStyleUpdateNotificationKey
BOOL	canApplyBlurBackdrop = YES
static NSString *const	kAccessibilityLoadCompleteNotification = @"@"AXLoadComplete"
static NSString *const	kAccessibilityInvalidStatusChangedNotification = @"@"AXInvalidStatusChanged"
static NSString *const	kAccessibilityLiveRegionCreatedNotification = @"@"AXLiveRegionCreated"
static NSString *const	kAccessibilityLiveRegionChangedNotification = @"@"AXLiveRegionChanged"
static NSString *const	kAccessibilityExpandedChanged = @"@"AXExpandedChanged"
static NSString *const	kAccessibilityMenuItemSelectedNotification = @"@"AXMenuItemSelected"
const uint64_t	kValueMask = 0x000ffffffff
const uint64_t	kUnicodePlane = 0x00000000000
const uint64_t	kMacosPlane = 0x01400000000
const NSDictionary *	keyCodeToPhysicalKey
const NSDictionary *	keyCodeToLogicalKey
const NSDictionary *	keyCodeToModifierFlag
const NSDictionary *	modifierFlagToKeyCode
const uint64_t	kCapsLockPhysicalKey = 0x00070039
const uint64_t	kCapsLockLogicalKey = 0x100000104
const std::vector< LayoutGoal >	kLayoutGoals
static const auto	kRootViewIdentifier = EmbedderExternalView::ViewIdentifier{}
constexpr const char *	kFlutterThreadName = "io.flutter"
constexpr int	kOpaqueBlack = 0xff000000
constexpr FlutterViewId	kImplicitViewId = 0
constexpr int	kShift = 1 << 0
constexpr int	kControl = 1 << 3
constexpr int	kScanCodeShiftLeft = 0x2a
constexpr int	kScanCodeShiftRight = 0x36
constexpr int	kKeyCodeShiftLeft = 0xa0
constexpr int	kScanCodeControlLeft = 0x1d
constexpr int	kScanCodeControlRight = 0xe01d
constexpr int	kKeyCodeControlLeft = 0xa2
constexpr int	kDeadKeyCharMask = 0x80000000
static constexpr const char *	kExitTypeNames []
constexpr const wchar_t	kGetPreferredLanguageRegKey []
constexpr const wchar_t	kGetPreferredLanguageRegValue [] = L"Languages"
static absl::NoDestructor< std::unique_ptr< Shell > >	g_shell

Typedef Documentation

AccessibilityNodeId

typedef ui::AXNode::AXID flutter::AccessibilityNodeId

Definition at line 15 of file flutter_platform_node_delegate.h.

BinaryMessageHandler

typedef std::function< void(const uint8_t* message, size_t message_size, BinaryReply reply)> flutter::BinaryMessageHandler

Definition at line 24 of file binary_messenger.h.

BinaryReply

typedef std::function<void(const uint8_t* reply, size_t reply_size)> flutter::BinaryReply

Definition at line 17 of file binary_messenger.h.

ChildIsolatePreparer

using flutter::ChildIsolatePreparer = typedef std::function<bool(DartIsolate*)>

Definition at line 23 of file dart_isolate_group_data.h.

CurrentTimeProc

typedef uint64_t(* flutter::CurrentTimeProc) ()

Definition at line 21 of file task_runner.h.

CustomAccessibilityActionUpdates

using flutter::CustomAccessibilityActionUpdates = typedef std::unordered_map<int32_t, CustomAccessibilityAction>

Definition at line 31 of file custom_accessibility_action.h.

DisplayId

typedef size_t flutter::DisplayId

Unique ID per display that is stable until the Flutter application restarts. See also: flutter::Display

Definition at line 17 of file display.h.

DlDegrees

using flutter::DlDegrees = typedef impeller::Degrees

Definition at line 20 of file dl_geometry_types.h.

DlIPoint

using flutter::DlIPoint = typedef impeller::IPoint32

Definition at line 24 of file dl_geometry_types.h.

DlIRect

using flutter::DlIRect = typedef impeller::IRect32

Definition at line 28 of file dl_geometry_types.h.

DlISize

using flutter::DlISize = typedef impeller::ISize32

Definition at line 26 of file dl_geometry_types.h.

DlMatrix

using flutter::DlMatrix = typedef impeller::Matrix

Definition at line 29 of file dl_geometry_types.h.

DlPoint

using flutter::DlPoint = typedef impeller::Point

Definition at line 23 of file dl_geometry_types.h.

DlRadians

using flutter::DlRadians = typedef impeller::Radians

Definition at line 21 of file dl_geometry_types.h.

DlRect

using flutter::DlRect = typedef impeller::Rect

Definition at line 27 of file dl_geometry_types.h.

DlScalar

using flutter::DlScalar = typedef impeller::Scalar

Definition at line 19 of file dl_geometry_types.h.

DlSize

using flutter::DlSize = typedef impeller::Size

Definition at line 25 of file dl_geometry_types.h.

EGLResult

template<class T >

using flutter::EGLResult = typedef std::pair<bool, T>

Definition at line 15 of file android_context_gl_skia.cc.

EncodableList

using flutter::EncodableList = typedef std::vector<EncodableValue>

Definition at line 94 of file encodable_value.h.

EncodableMap

using flutter::EncodableMap = typedef std::map<EncodableValue, EncodableValue>

Definition at line 95 of file encodable_value.h.

Flags

using flutter::Flags = typedef DlVertices::Builder::Flags

Definition at line 12 of file dl_vertices.cc.

FlutterViewId

typedef int64_t flutter::FlutterViewId

Definition at line 13 of file flutter_view.h.

FramePipeline

using flutter::FramePipeline = typedef Pipeline<FrameItem>

Definition at line 98 of file rasterizer.h.

FrameRasterizedCallback

using flutter::FrameRasterizedCallback = typedef std::function<void(const FrameTiming&)>

Definition at line 97 of file settings.h.

GPUCAMetalLayerHandle

typedef void* flutter::GPUCAMetalLayerHandle

Definition at line 24 of file gpu_surface_metal_delegate.h.

GPUMTLCommandQueueHandle

typedef void* flutter::GPUMTLCommandQueueHandle

Definition at line 21 of file gpu_surface_metal_delegate.h.

GPUMTLDestructionCallback

typedef void(* flutter::GPUMTLDestructionCallback) (void *)

Definition at line 29 of file gpu_surface_metal_delegate.h.

GPUMTLDeviceHandle

typedef void* flutter::GPUMTLDeviceHandle

Definition at line 18 of file gpu_surface_metal_delegate.h.

GPUMTLTextureHandle

typedef const void* flutter::GPUMTLTextureHandle

Definition at line 27 of file gpu_surface_metal_delegate.h.

Gradient

typedef CanvasGradient flutter::Gradient

Definition at line 57 of file dart_ui.cc.

HardwareBufferKey

using flutter::HardwareBufferKey = typedef uint64_t

Definition at line 22 of file image_lru.h.

Image

typedef CanvasImage flutter::Image

Definition at line 55 of file dart_ui.cc.

ImageGeneratorFactory

using flutter::ImageGeneratorFactory = typedef 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.

Definition at line 21 of file image_generator_registry.h.

JavaLocalRef

using flutter::JavaLocalRef = typedef std::nullptr_t

Definition at line 27 of file platform_view_android_jni.h.

KeyboardLayoutNotifier

typedef void(^ flutter::KeyboardLayoutNotifier) ()

Definition at line 16 of file FlutterKeyboardViewDelegate.h.

LayerVariant

using flutter::LayerVariant = typedef std::variant<PlatformViewLayer, BackingStoreLayer>

Definition at line 29 of file FlutterCompositor.h.

LogMessageCallback

using flutter::LogMessageCallback = typedef std::function<void(const std::string& , const std::string& )>

Definition at line 87 of file settings.h.

MappingCallback

using flutter::MappingCallback = typedef std::function<std::unique_ptr<fml::Mapping>(void)>

Definition at line 93 of file settings.h.

Mappings

using flutter::Mappings = typedef std::vector<std::unique_ptr<const fml::Mapping> >

Definition at line 94 of file settings.h.

MappingsCallback

using flutter::MappingsCallback = typedef std::function<Mappings(void)>

Definition at line 95 of file settings.h.

MessageHandler

template<typename T >

using flutter::MessageHandler = typedef std::function<void(const T& message, const MessageReply<T>& reply)>

Definition at line 50 of file basic_message_channel.h.

MessageReply

template<typename T >

using flutter::MessageReply = typedef std::function<void(const T& reply)>

Definition at line 43 of file basic_message_channel.h.

MethodCallHandler

template<typename T >

using flutter::MethodCallHandler = typedef std::function<void(const MethodCall<T>& call, std::unique_ptr<MethodResult<T> > result)>

Definition at line 27 of file method_channel.h.

MutatorContext

using flutter::MutatorContext = typedef LayerStateStack::MutatorContext

Definition at line 530 of file layer_state_stack.cc.

PaintRegionMap

using flutter::PaintRegionMap = typedef std::map<uint64_t, PaintRegion>

Definition at line 41 of file diff_context.h.

Path

typedef CanvasPath flutter::Path

Definition at line 58 of file dart_ui.cc.

PathMeasure

typedef CanvasPathMeasure flutter::PathMeasure

Definition at line 56 of file dart_ui.cc.

PointerDataDispatcherMaker

using flutter::PointerDataDispatcherMaker = typedef std::function<std::unique_ptr<PointerDataDispatcher>( PointerDataDispatcher::Delegate&)>

Signature for constructing PointerDataDispatcher.

Parameters

[in]

delegate

the Flutter::Engine

Definition at line 171 of file pointer_data_dispatcher.h.

ProductVersion

using flutter::ProductVersion = typedef std::tuple<int32_t , int32_t , int32_t >

Definition at line 14 of file availability_version_check.h.

ResultHandlerError

template<typename T >

using flutter::ResultHandlerError = typedef std::function<void(const std::string& error_code, const std::string& error_message, const T* error_details)>

Definition at line 22 of file method_result_functions.h.

ResultHandlerNotImplemented

template<typename T >

using flutter::ResultHandlerNotImplemented = typedef std::function<void()>

Definition at line 26 of file method_result_functions.h.

ResultHandlerSuccess

template<typename T >

using flutter::ResultHandlerSuccess = typedef std::function<void(const T* result)>

Definition at line 20 of file method_result_functions.h.

Sampler

using flutter::Sampler = typedef 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.

See also

flutter::SamplingProfiler::SampleRepeatedly

Definition at line 73 of file sampling_profiler.h.

SemanticsNodeUpdates

using flutter::SemanticsNodeUpdates = typedef std::unordered_map<int32_t, SemanticsNode>

Definition at line 153 of file semantics_node.h.

SkiaUnrefQueue

using flutter::SkiaUnrefQueue = typedef UnrefQueue<GrDirectContext>

Definition at line 161 of file skia_gpu_object.h.

StreamHandlerCancel

template<typename T >

using flutter::StreamHandlerCancel = typedef std::function<std::unique_ptr<StreamHandlerError<T> >(const T* arguments)>

Definition at line 26 of file event_stream_handler_functions.h.

StreamHandlerListen

template<typename T >

using flutter::StreamHandlerListen = typedef std::function<std::unique_ptr<StreamHandlerError<T> >( const T* arguments, std::unique_ptr<EventSink<T> >&& events)>

Definition at line 20 of file event_stream_handler_functions.h.

StringAttributePtr

using flutter::StringAttributePtr = typedef std::shared_ptr<flutter::StringAttribute>

Definition at line 15 of file string_attribute.h.

StringAttributes

using flutter::StringAttributes = typedef std::vector<StringAttributePtr>

Definition at line 16 of file string_attribute.h.

TaskObserverAdd

using flutter::TaskObserverAdd = typedef std::function<void(intptr_t , fml::closure )>

Definition at line 81 of file settings.h.

TaskObserverRemove

using flutter::TaskObserverRemove = typedef std::function<void(intptr_t )>

Definition at line 83 of file settings.h.

TextureVariant

typedef std::variant<PixelBufferTexture, GpuSurfaceTexture> flutter::TextureVariant

Definition at line 79 of file texture_registrar.h.

ThreadConfig

using flutter::ThreadConfig = typedef fml::Thread::ThreadConfig

Definition at line 17 of file thread_host.h.

ThreadConfigSetter

using flutter::ThreadConfigSetter = typedef fml::Thread::ThreadConfigSetter

Definition at line 18 of file thread_host.h.

UnhandledExceptionCallback

using flutter::UnhandledExceptionCallback = typedef std::function<bool(const std::string& , const std::string& )>

Definition at line 84 of file settings.h.

UniqueAotDataPtr

using flutter::UniqueAotDataPtr = typedef std::unique_ptr<_FlutterEngineAOTData, FlutterEngineCollectAOTDataFnPtr>

Definition at line 17 of file flutter_project_bundle.h.

WindowProcDelegate

using flutter::WindowProcDelegate = typedef std::function<std::optional< LRESULT>(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)>

Definition at line 23 of file plugin_registrar_windows.h.

Enumeration Type Documentation

AccessibilityFeatureFlag

enum class flutter::AccessibilityFeatureFlag : int32_t

strong

An enum for defining the different kinds of accessibility features that can be enabled by the platform.

Must match the AccessibilityFeatures class in framework.

Enumerator
kAccessibleNavigation
kInvertColors
kDisableAnimations
kBoldText
kReduceMotion
kHighContrast
kOnOffSwitchLabels

Definition at line 36 of file platform_configuration.h.

                                    : int32_t {
  kAccessibleNavigation = 1 << 0,
  kInvertColors = 1 << 1,
  kDisableAnimations = 1 << 2,
  kBoldText = 1 << 3,
  kReduceMotion = 1 << 4,
  kHighContrast = 1 << 5,
  kOnOffSwitchLabels = 1 << 6,
};

AndroidEGLSurfaceMakeCurrentStatus

enum class flutter::AndroidEGLSurfaceMakeCurrentStatus

strong

Result of calling MakeCurrent on AndroidEGLSurface.

Enumerator
kSuccessAlreadyCurrent	Success, the egl context for the surface was already current.
kSuccessMadeCurrent	Success, the egl context for the surface made current.
kFailure	Failed to make the egl context for the surface current.

Definition at line 30 of file android_egl_surface.h.

                                              {
  /// Success, the egl context for the surface was already current.
  kSuccessAlreadyCurrent,
  /// Success, the egl context for the surface made current.
  kSuccessMadeCurrent,
  /// Failed to make the egl context for the surface current.
  kFailure,
};

AndroidRenderingAPI

enum class flutter::AndroidRenderingAPI

strong

Enumerator
kSoftware
kImpellerOpenGLES
kImpellerVulkan
kSkiaOpenGLES

Definition at line 26 of file settings.h.

                               {
  kSoftware,
  kImpellerOpenGLES,
  kImpellerVulkan,
  kSkiaOpenGLES
};

AppExitType

enum class flutter::AppExitType

strong

Enumerator
required
cancelable

Definition at line 27 of file platform_handler.h.

                       {
  required,
  cancelable,
};

AppLifecycleState

enum class flutter::AppLifecycleState

strong

These constants describe the possible lifecycle states of the application. They must be kept up to date with changes in the framework's AppLifecycleState enum. They are passed to the embedder's |SetLifecycleState| function.

States not supported on a platform will be synthesized by the framework when transitioning between states which are supported, so that all implementations share the same state machine.

Here is the state machine:

+-----------+                               +-----------+
| detached  |------------------------------>|  resumed  |
+-----------+                               +-----------+
     ^                                              ^
     |                                              |
     |                                              v
+-----------+        +--------------+       +-----------+
| paused    |<------>|    hidden    |<----->|  inactive |
+-----------+        +--------------+       +-----------+

Enumerator
kDetached	Corresponds to the Framework's AppLifecycleState.detached: The initial state of the state machine. On Android, iOS, and web, also the final state of the state machine when all views are detached. Other platforms do not re-enter this state after initially leaving it.
kResumed	Corresponds to the Framework's AppLifecycleState.resumed: The nominal "running" state of the application. The application is visible, has input focus, and is running.
kInactive	Corresponds to the Framework's AppLifecycleState.inactive: At least one view of the application is visible, but none have input focus. The application is otherwise running normally.
kHidden	Corresponds to the Framework's AppLifecycleState.hidden: All views of an application are hidden, either because the application is being stopped (on iOS and Android), or because it is being minimized or on a desktop that is no longer visible (on desktop), or on a tab that is no longer visible (on web).
kPaused	Corresponds to the Framework's AppLifecycleState.paused: The application is not running, and can be detached or started again at any time. This state is typically only entered into on iOS and Android.

Definition at line 32 of file app_lifecycle_state.h.

                             {
  /**
   * Corresponds to the Framework's AppLifecycleState.detached: The initial
   * state of the state machine. On Android, iOS, and web, also the final state
   * of the state machine when all views are detached. Other platforms do not
   * re-enter this state after initially leaving it.
   */
  kDetached,
 
  /**
   * Corresponds to the Framework's AppLifecycleState.resumed: The nominal
   * "running" state of the application. The application is visible, has input
   * focus, and is running.
   */
  kResumed,
 
  /**
   * Corresponds to the Framework's AppLifecycleState.inactive: At least one
   * view of the application is visible, but none have input focus. The
   * application is otherwise running normally.
   */
  kInactive,
 
  /**
   * Corresponds to the Framework's AppLifecycleState.hidden: All views of an
   * application are hidden, either because the application is being stopped (on
   * iOS and Android), or because it is being minimized or on a desktop that is
   * no longer visible (on desktop), or on a tab that is no longer visible (on
   * web).
   */
  kHidden,
 
  /**
   * Corresponds to the Framework's AppLifecycleState.paused: The application is
   * not running, and can be detached or started again at any time. This state
   * is typically only entered into on iOS and Android.
   */
  kPaused,
};

Clip

enum flutter::Clip

Enumerator
kNone
kHardEdge
kAntiAlias
kAntiAliasWithSaveLayer

Definition at line 53 of file layer.h.

{ kNone, kHardEdge, kAntiAlias, kAntiAliasWithSaveLayer };

ColorSpace

enum flutter::ColorSpace

Enumerator
kSRGB
kExtendedSRGB

Definition at line 16 of file image.h.

                {
  kSRGB,
  kExtendedSRGB,
};

ContextType

enum class flutter::ContextType

strong

Enumerator
kRender	The context is used to render to a texture or renderbuffer.
kResource	The context will only be used to transfer resources to and from device memory. No rendering will be performed using this context.

Definition at line 17 of file context_options.h.

                       {
  /// The context is used to render to a texture or renderbuffer.
  kRender,
  /// The context will only be used to transfer resources to and from device
  /// memory. No rendering will be performed using this context.
  kResource,
};

DartErrorCode

enum class flutter::DartErrorCode

strong

Error exit codes for the Dart isolate.

Enumerator
NoError	No error has occurred.
ApiError	The Dart error code for an API error.
CompilationError	The Dart error code for a compilation error.
UnknownError	The Dart error code for an unknown error.

Definition at line 49 of file shell.h.

                         {
  // NOLINTBEGIN(readability-identifier-naming)
  /// No error has occurred.
  NoError = 0,
  /// The Dart error code for an API error.
  ApiError = 253,
  /// The Dart error code for a compilation error.
  CompilationError = 254,
  /// The Dart error code for an unknown error.
  UnknownError = 255
  // NOLINTEND(readability-identifier-naming)
};

DisplayListCompare

enum class flutter::DisplayListCompare

strong

Enumerator
kUseBulkCompare
kNotEqual
kEqual

Definition at line 72 of file dl_op_records.h.

                              {
  // The Op is deferring comparisons to a bulk memcmp performed lazily
  // across all bulk-comparable ops.
  kUseBulkCompare,
 
  // The Op provided a specific equals method that spotted a difference
  kNotEqual,
 
  // The Op provided a specific equals method that saw no differences
  kEqual,
};

DisplayListOpType

enum class flutter::DisplayListOpType

strong

Definition at line 141 of file display_list.h.

                             {
  FOR_EACH_DISPLAY_LIST_OP(DL_OP_TO_ENUM_VALUE)
#ifdef IMPELLER_ENABLE_3D
      DL_OP_TO_ENUM_VALUE(SetSceneColorSource)
#endif  // IMPELLER_ENABLE_3D
};

DlBlendMode

enum class flutter::DlBlendMode

strong

A enum define the blend mode. Blends are operators that take in two colors (source, destination) and return a new color. Many of these operate the same on all 4 components: red, green, blue, alpha. For these, we just document what happens to one component, rather than naming each one separately. Different color types might have different representations for color components: 8-bit: 0..255 6-bit: 0..63 5-bit: 0..31 4-bit: 0..15 floats: 0...1 The comments are expressed as if the component values are always 0..1 (floats). For brevity, the documentation uses the following abbreviations s : source d : destination sa : source alpha da : destination alpha Results are abbreviated r : if all 4 components are computed in the same manner ra : result alpha component rc : result "color": red, green, blue components

Enumerator
kClear	r = 0
kSrc	r = s
kDst	r = d
kSrcOver	r = s + (1-sa)*d
kDstOver	r = d + (1-da)*s
kSrcIn	r = s * da
kDstIn	r = d * sa
kSrcOut	r = s * (1-da)
kDstOut	r = d * (1-sa)
kSrcATop	r = s*da + d*(1-sa)
kDstATop	r = d*sa + s*(1-da)
kXor	r = s*(1-da) + d*(1-sa)
kPlus	r = min(s + d, 1)
kModulate	r = s*d
kScreen	r = s + d - s*d
kOverlay	multiply or screen, depending on destination
kDarken	rc = s + d - max(s*da, d*sa), ra = kSrcOver
kLighten	rc = s + d - min(s*da, d*sa), ra = kSrcOver
kColorDodge	brighten destination to reflect source
kColorBurn	darken destination to reflect source
kHardLight	multiply or screen, depending on source
kSoftLight	lighten or darken, depending on source
kDifference	rc = s + d - 2*(min(s*da, d*sa)), ra = kSrcOver
kExclusion	rc = s + d - two(s*d), ra = kSrcOver
kMultiply	r = s*(1-da) + d*(1-sa) + s*d
kHue	hue of source with saturation and luminosity of destination
kSaturation	saturation of source with hue and luminosity of destination
kColor	hue and saturation of source with luminosity of destination
kLuminosity	luminosity of source with hue and saturation of destination
kLastCoeffMode	last porter duff blend mode
kLastSeparableMode	last blend mode operating separately on components
kLastMode	last valid value
kDefaultMode

Definition at line 26 of file dl_blend_mode.h.

                       {
  kClear,     //!< r = 0
  kSrc,       //!< r = s
  kDst,       //!< r = d
  kSrcOver,   //!< r = s + (1-sa)*d
  kDstOver,   //!< r = d + (1-da)*s
  kSrcIn,     //!< r = s * da
  kDstIn,     //!< r = d * sa
  kSrcOut,    //!< r = s * (1-da)
  kDstOut,    //!< r = d * (1-sa)
  kSrcATop,   //!< r = s*da + d*(1-sa)
  kDstATop,   //!< r = d*sa + s*(1-da)
  kXor,       //!< r = s*(1-da) + d*(1-sa)
  kPlus,      //!< r = min(s + d, 1)
  kModulate,  //!< r = s*d
  kScreen,    //!< r = s + d - s*d
 
  kOverlay,     //!< multiply or screen, depending on destination
  kDarken,      //!< rc = s + d - max(s*da, d*sa), ra = kSrcOver
  kLighten,     //!< rc = s + d - min(s*da, d*sa), ra = kSrcOver
  kColorDodge,  //!< brighten destination to reflect source
  kColorBurn,   //!< darken destination to reflect source
  kHardLight,   //!< multiply or screen, depending on source
  kSoftLight,   //!< lighten or darken, depending on source
  kDifference,  //!< rc = s + d - 2*(min(s*da, d*sa)), ra = kSrcOver
  kExclusion,   //!< rc = s + d - two(s*d), ra = kSrcOver
  kMultiply,    //!< r = s*(1-da) + d*(1-sa) + s*d
 
  kHue,         //!< hue of source with saturation and luminosity of destination
  kSaturation,  //!< saturation of source with hue and luminosity of destination
  kColor,       //!< hue and saturation of source with luminosity of destination
  kLuminosity,  //!< luminosity of source with hue and saturation of destination
 
  kLastCoeffMode = kScreen,  //!< last porter duff blend mode
  kLastSeparableMode =
      kMultiply,  //!< last blend mode operating separately on components
  kLastMode = kLuminosity,  //!< last valid value
  kDefaultMode = kSrcOver,
};

DlBlurStyle

enum class flutter::DlBlurStyle

strong

Enumerator
kNormal	fuzzy inside and outside
kSolid	solid inside, fuzzy outside
kOuter	nothing inside, fuzzy outside
kInner	fuzzy inside, nothing outside

Definition at line 24 of file dl_mask_filter.h.

                       {
  kNormal,  //!< fuzzy inside and outside
  kSolid,   //!< solid inside, fuzzy outside
  kOuter,   //!< nothing inside, fuzzy outside
  kInner,   //!< fuzzy inside, nothing outside
};

DlColorFilterType

enum class flutter::DlColorFilterType

strong

Enumerator
kBlend
kMatrix
kSrgbToLinearGamma
kLinearToSrgbGamma

Definition at line 23 of file dl_color_filter.h.

                             {
  kBlend,
  kMatrix,
  kSrgbToLinearGamma,
  kLinearToSrgbGamma,
};

DlColorSourceType

enum class flutter::DlColorSourceType

strong

Enumerator
kColor
kImage
kLinearGradient
kRadialGradient
kConicalGradient
kSweepGradient
kRuntimeEffect

Definition at line 51 of file dl_color_source.h.

                             {
  kColor,
  kImage,
  kLinearGradient,
  kRadialGradient,
  kConicalGradient,
  kSweepGradient,
  kRuntimeEffect,
#ifdef IMPELLER_ENABLE_3D
  kScene,
#endif  // IMPELLER_ENABLE_3D
};

DlDrawStyle

enum class flutter::DlDrawStyle

strong

Enumerator
kFill	fills interior of shapes
kStroke	strokes boundary of shapes
kStrokeAndFill	both strokes and fills shapes
kLastStyle
kDefaultStyle

Definition at line 19 of file dl_paint.h.

                       {
  kFill,           //!< fills interior of shapes
  kStroke,         //!< strokes boundary of shapes
  kStrokeAndFill,  //!< both strokes and fills shapes
 
  kLastStyle = kStrokeAndFill,
  kDefaultStyle = kFill,
};

DlFilterMode

enum class flutter::DlFilterMode

strong

Enumerator
kNearest
kLinear
kLast

Definition at line 10 of file dl_sampling_options.h.

                        {
  kNearest,  // single sample point (nearest neighbor)
  kLinear,   // interporate between 2x2 sample points (bilinear interpolation)
 
  kLast = kLinear,
};

DlImageFilterType

enum class flutter::DlImageFilterType

strong

Enumerator
kBlur
kDilate
kErode
kMatrix
kCompose
kColorFilter
kLocalMatrix

Definition at line 29 of file dl_image_filter.h.

                             {
  kBlur,
  kDilate,
  kErode,
  kMatrix,
  kCompose,
  kColorFilter,
  kLocalMatrix,
};

DlImageSampling

enum class flutter::DlImageSampling

strong

Enumerator
kNearestNeighbor
kLinear
kMipmapLinear
kCubic

Definition at line 17 of file dl_sampling_options.h.

                           {
  kNearestNeighbor,
  kLinear,
  kMipmapLinear,
  kCubic,
};

DlMaskFilterType

enum class flutter::DlMaskFilterType

strong

Enumerator
kBlur

Definition at line 22 of file dl_mask_filter.h.

{ kBlur };

DlStrokeCap

enum class flutter::DlStrokeCap

strong

Enumerator
kButt	no stroke extension
kRound	adds circle
kSquare	adds square
kLastCap
kDefaultCap

Definition at line 28 of file dl_paint.h.

                       {
  kButt,    //!< no stroke extension
  kRound,   //!< adds circle
  kSquare,  //!< adds square
 
  kLastCap = kSquare,
  kDefaultCap = kButt,
};

DlStrokeJoin

enum class flutter::DlStrokeJoin

strong

Enumerator
kMiter	extends to miter limit
kRound	adds circle
kBevel	connects outside edges
kLastJoin
kDefaultJoin

Definition at line 37 of file dl_paint.h.

                        {
  kMiter,  //!< extends to miter limit
  kRound,  //!< adds circle
  kBevel,  //!< connects outside edges
 
  kLastJoin = kBevel,
  kDefaultJoin = kMiter,
};

DlTileMode

enum class flutter::DlTileMode

strong

Enumerator
kClamp
kRepeat
kMirror
kDecal

Definition at line 13 of file dl_tile_mode.h.

                      {
  // Replicate the edge color if the |DlColorSource| draws outside of the
  // defined bounds.
  kClamp,
 
  // Repeat the |DlColorSource|'s defined colors both horizontally and
  // vertically (or both along and perpendicular to a gradient's geometry).
  kRepeat,
 
  // Repeat the |DlColorSource|'s colors horizontally and vertically,
  // alternating mirror images so that adjacent images always seam.
  kMirror,
 
  // Only draw within the original domain, return transparent-black everywhere
  // else.
  kDecal,
};

DlVertexMode

enum class flutter::DlVertexMode

strong

Defines the way in which the vertices of a DlVertices object are separated into triangles into which to render.

Enumerator
kTriangles	The vertices are taken 3 at a time to form a triangle.
kTriangleStrip	The vertices are taken in overlapping triplets to form triangles, with each triplet sharing 2 of its vertices with the preceding and following triplets. vertices [ABCDE] yield 3 triangles ABC,BCD,CDE
kTriangleFan	The vertices are taken in overlapping pairs and combined with the first vertex to form triangles that radiate outward from the initial point. vertices [ABCDE] yield 3 triangles ABC,ACD,ADE

Definition at line 20 of file dl_vertices.h.

                        {
  /// The vertices are taken 3 at a time to form a triangle.
  kTriangles,
 
  /// The vertices are taken in overlapping triplets to form triangles, with
  /// each triplet sharing 2 of its vertices with the preceding and following
  /// triplets.
  /// vertices [ABCDE] yield 3 triangles ABC,BCD,CDE
  kTriangleStrip,
 
  /// The vertices are taken in overlapping pairs and combined with the first
  /// vertex to form triangles that radiate outward from the initial point.
  /// vertices [ABCDE] yield 3 triangles ABC,ACD,ADE
  kTriangleFan,
};

DrawStatus

enum class flutter::DrawStatus

strong

Enumerator
kDone
kNotSetUp
kYielded
kPipelineEmpty
kGpuUnavailable

Definition at line 53 of file rasterizer.h.

                      {
  // The drawing was done without any specified status.
  kDone,
  // Failed to rasterize the frame because the Rasterizer is not set up.
  kNotSetUp,
  // Nothing was done, because the call was not on the raster thread. Yielded to
  // let this frame be serviced on the right thread.
  kYielded,
  // Nothing was done, because the pipeline was empty.
  kPipelineEmpty,
  // Nothing was done, because the GPU was unavailable.
  kGpuUnavailable,
};

DrawSurfaceStatus

enum class flutter::DrawSurfaceStatus

strong

Enumerator
kSuccess
kRetry
kFailed
kDiscarded

Definition at line 68 of file rasterizer.h.

                             {
  // The layer tree was successfully rasterized.
  kSuccess,
  // The layer tree must be submitted again.
  //
  // This can occur on Android when switching the background surface to
  // FlutterImageView.  On Android, the first frame doesn't make the image
  // available to the ImageReader right away. The second frame does.
  // TODO(egarciad): https://github.com/flutter/flutter/issues/65652
  //
  // This can also occur when the frame is dropped to wait for the thread
  // merger to merge the raster and platform threads.
  kRetry,
  // Failed to rasterize the frame.
  kFailed,
  // Layer tree was discarded because its size does not match the view size.
  // This typically occurs during resizing.
  kDiscarded,
};

FocusChangeDirection

enum class flutter::FocusChangeDirection

strong

Enumerator
kProgrammatic
kForward
kBackward

Definition at line 17 of file platform_view_manager.h.

                                {
  kProgrammatic,  // Un-directed focus change.
  kForward,       // Keyboard focus moves forwards, e.g. TAB key.
  kBackward       // Keyboard focus moves backwards, e.g. Shift+TAB.
};

GpuAvailability

enum class flutter::GpuAvailability

strong

Values for |Shell::SetGpuAvailability|.

Enumerator
kAvailable	Indicates that GPU operations should be permitted.
kFlushAndMakeUnavailable	Indicates that the GPU is about to become unavailable, and to attempt to flush any GPU related resources now.
kUnavailable	Indicates that the GPU is unavailable, and that no attempt should be made to even flush GPU objects until it is available again.

Definition at line 63 of file shell.h.

                           {
  /// Indicates that GPU operations should be permitted.
  kAvailable = 0,
  /// Indicates that the GPU is about to become unavailable, and to attempt to
  /// flush any GPU related resources now.
  kFlushAndMakeUnavailable = 1,
  /// Indicates that the GPU is unavailable, and that no attempt should be made
  /// to even flush GPU objects until it is available again.
  kUnavailable = 2
};

ImageByteFormat

enum flutter::ImageByteFormat

Enumerator
kRawRGBA
kRawStraightRGBA
kRawUnmodified
kRawExtendedRgba128
kPNG

Definition at line 17 of file image_encoding.h.

                     {
  kRawRGBA,
  kRawStraightRGBA,
  kRawUnmodified,
  kRawExtendedRgba128,
  kPNG,
};

IOSRenderingAPI

enum class flutter::IOSRenderingAPI

strong

Enumerator
kSoftware
kMetal

Definition at line 14 of file rendering_api_selection.h.

                           {
  kSoftware,
  kMetal,
};

IOSRenderingBackend

enum class flutter::IOSRenderingBackend

strong

Enumerator
kSkia
kImpeller

Definition at line 19 of file rendering_api_selection.h.

                               {
  kSkia,
  kImpeller,
};

IsolateLaunchType

enum class flutter::IsolateLaunchType

strong

Describes whether the isolate is part of a group or not.

If the isolate is part of a group, it avoids reloading the kernel snapshot.

Enumerator
kNewGroup	The isolate is launched as a solo isolate or to start a new group.
kExistingGroup	The isolate is launched as part of a group, and avoids reloading the kernel snapshot.

Definition at line 25 of file isolate_configuration.h.

                             {
  /// The isolate is launched as a solo isolate or to start a new group.
  kNewGroup,
  /// The isolate is launched as part of a group, and avoids reloading the
  /// kernel snapshot.
  kExistingGroup,
};

KeyEventDeviceType

enum class flutter::KeyEventDeviceType : int64_t

strong

Enumerator
kKeyboard
kDirectionalPad
kGamepad
kJoystick
kHdmi

Definition at line 34 of file key_data.h.

                              : int64_t {
  // The source is a keyboard.
  kKeyboard = 0,
 
  // The source is a directional pad on something like a television remote
  // control or similar.
  kDirectionalPad,
 
  // The source is a gamepad button.
  kGamepad,
 
  // The source is a joystick button.
  kJoystick,
 
  // The source is a device connected to an HDMI bus.
  kHdmi,
};

KeyEventType

enum class flutter::KeyEventType : int64_t

strong

Enumerator
kDown
kUp
kRepeat

Definition at line 22 of file key_data.h.

                        : int64_t {
  kDown = 0,
  kUp,
  kRepeat,
};

MaskFilterType

enum flutter::MaskFilterType

Enumerator
kNull
kBlur

Definition at line 59 of file paint.cc.

{ kNull, kBlur };

ModifierFlag

enum flutter::ModifierFlag

Bits in |NSEvent.modifierFlags| indicating whether a modifier key is pressed.

These constants are not written in the official documentation, but derived from experiments. This is currently the only way to know whether a one-side modifier key (such as ShiftLeft) is pressed, instead of the general combined modifier state (such as Shift).

Enumerator
kModifierFlagControlLeft
kModifierFlagShiftLeft
kModifierFlagShiftRight
kModifierFlagMetaLeft
kModifierFlagMetaRight
kModifierFlagAltLeft
kModifierFlagAltRight
kModifierFlagControlRight

Definition at line 79 of file KeyCodeMap_Internal.h.

             {
  kModifierFlagControlLeft = 0x1,
  kModifierFlagShiftLeft = 0x2,
  kModifierFlagShiftRight = 0x4,
  kModifierFlagMetaLeft = 0x8,
  kModifierFlagMetaRight = 0x10,
  kModifierFlagAltLeft = 0x20,
  kModifierFlagAltRight = 0x40,
  kModifierFlagControlRight = 0x200,
} ModifierFlag;

MTLRenderTargetType

enum class flutter::MTLRenderTargetType

strong

Enumerator
kMTLTexture
kCAMetalLayer

Definition at line 38 of file gpu_surface_metal_delegate.h.

{ kMTLTexture, kCAMetalLayer };

MutatorType

enum flutter::MutatorType

Enumerator
kClipRect
kClipRRect
kClipPath
kTransform
kOpacity
kBackdropFilter

Definition at line 37 of file embedded_views.h.

                 {
  kClipRect,
  kClipRRect,
  kClipPath,
  kTransform,
  kOpacity,
  kBackdropFilter
};

PipelineConsumeResult

enum class flutter::PipelineConsumeResult

strong

Enumerator
NoneAvailable
Done
MoreAvailable

Definition at line 29 of file pipeline.h.

                                 {
  // NOLINTBEGIN(readability-identifier-naming)
  NoneAvailable,
  Done,
  MoreAvailable,
  // NOLINTEND(readability-identifier-naming)
};

PlatformProvidedMenu

enum class flutter::PlatformProvidedMenu

strong

Enumerator
kAbout
kQuit
kServicesSubmenu
kHide
kHideOtherApplications
kShowAllApplications
kStartSpeaking
kStopSpeaking
kToggleFullScreen
kMinimizeWindow
kZoomWindow
kArrangeWindowsInFront

Definition at line 12 of file platform_provided_menu.h.

                                {
  // orderFrontStandardAboutPanel macOS provided menu
  kAbout,
 
  // terminate macOS provided menu
  kQuit,
 
  // Services macOS provided submenu.
  kServicesSubmenu,
 
  // hide macOS provided menu
  kHide,
 
  // hideOtherApplications macOS provided menu
  kHideOtherApplications,
 
  // unhideAllApplications macOS provided menu
  kShowAllApplications,
 
  // startSpeaking macOS provided menu
  kStartSpeaking,
 
  // stopSpeaking macOS provided menu
  kStopSpeaking,
 
  // toggleFullScreen macOS provided menu
  kToggleFullScreen,
 
  // performMiniaturize macOS provided menu
  kMinimizeWindow,
 
  // performZoom macOS provided menu
  kZoomWindow,
 
  // arrangeInFront macOS provided menu
  kArrangeWindowsInFront,
};

PointerButtonMouse

enum flutter::PointerButtonMouse : int64_t

Enumerator
kPointerButtonMousePrimary
kPointerButtonMouseSecondary
kPointerButtonMouseMiddle
kPointerButtonMouseBack
kPointerButtonMouseForward

Definition at line 13 of file pointer_data.h.

                        : int64_t {
  kPointerButtonMousePrimary = 1 << 0,
  kPointerButtonMouseSecondary = 1 << 1,
  kPointerButtonMouseMiddle = 1 << 2,
  kPointerButtonMouseBack = 1 << 3,
  kPointerButtonMouseForward = 1 << 4,
};

PointerButtonStylus

enum flutter::PointerButtonStylus : int64_t

Enumerator
kPointerButtonStylusContact
kPointerButtonStylusPrimary
kPointerButtonStylusSecondary

Definition at line 25 of file pointer_data.h.

                         : int64_t {
  kPointerButtonStylusContact = 1 << 0,
  kPointerButtonStylusPrimary = 1 << 1,
  kPointerButtonStylusSecondary = 1 << 2,
};

PointerButtonTouch

enum flutter::PointerButtonTouch : int64_t

Enumerator
kPointerButtonTouchContact

Definition at line 21 of file pointer_data.h.

                        : int64_t {
  kPointerButtonTouchContact = 1 << 0,
};

PostPrerollResult

enum class flutter::PostPrerollResult

strong

Enumerator
kSuccess
kResubmitFrame
kSkipAndRetryFrame

Definition at line 318 of file embedded_views.h.

                             {
  // Frame has successfully rasterized.
  kSuccess,
  // Frame is submitted twice. This is currently only used when
  // thread configuration change occurs.
  kResubmitFrame,
  // Frame is dropped and a new frame with the same layer tree is
  // attempted. This is currently only used when thread configuration
  // change occurs.
  kSkipAndRetryFrame
};

RasterCacheKeyKind

enum class flutter::RasterCacheKeyKind

strong

Enumerator
kLayerMetrics
kDisplayListMetrics

Definition at line 77 of file raster_cache_key.h.

{ kLayerMetrics, kDisplayListMetrics };

RasterCacheKeyType

enum class flutter::RasterCacheKeyType

strong

Enumerator
kLayer
kDisplayList
kLayerChildren

Definition at line 23 of file raster_cache_key.h.

{ kLayer, kDisplayList, kLayerChildren };

RasterCacheLayerStrategy

enum class flutter::RasterCacheLayerStrategy

strong

Enumerator
kLayer
kLayerChildren

Definition at line 27 of file raster_cache.h.

{ kLayer, kLayerChildren };

RasterStatus

enum class flutter::RasterStatus

strong

Enumerator
kSuccess
kResubmit
kSkipAndRetry

Definition at line 28 of file compositor_context.h.

                        {
  // Frame has been successfully rasterized.
  kSuccess,
  // Frame has been submited, but must be submitted again. This is only used
  // on Android when switching the background surface to FlutterImageView.
  //
  // On Android, the first frame doesn't make the image available
  // to the ImageReader right away. The second frame does.
  //
  // TODO(egarciad): https://github.com/flutter/flutter/issues/65652
  kResubmit,
  // Frame has be dropped and a new frame with the same layer tree must be
  // attempted.
  //
  // This is currently used to wait for the thread merger to merge
  // the raster and platform threads.
  //
  // Since the thread merger may be disabled, the system will proceed
  // with separate threads for rasterization and platform tasks,
  // potentially leading to different performance characteristics.
  kSkipAndRetry,
};

SemanticsAction

enum class flutter::SemanticsAction : int32_t

strong

Enumerator
kTap
kLongPress
kScrollLeft
kScrollRight
kScrollUp
kScrollDown
kIncrease
kDecrease
kShowOnScreen
kMoveCursorForwardByCharacter
kMoveCursorBackwardByCharacter
kSetSelection
kCopy
kCut
kPaste
kDidGainAccessibilityFocus
kDidLoseAccessibilityFocus
kCustomAction
kDismiss
kMoveCursorForwardByWord
kMoveCursorBackwardByWord
kSetText
kFocus

Definition at line 22 of file semantics_node.h.

                           : 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,
  kFocus = 1 << 22,
};

SemanticsFlags

enum class flutter::SemanticsFlags : int32_t

strong

C/C++ representation of SemanticsFlags defined in lib/ui/semantics.dart.

Warning

This must match the SemanticsFlags enum in lib/ui/semantics.dart. See also:

• file://./../../../lib/ui/semantics.dart

Enumerator
kHasCheckedState
kIsChecked
kIsSelected
kIsButton
kIsTextField
kIsFocused
kHasEnabledState
kIsEnabled
kIsInMutuallyExclusiveGroup
kIsHeader
kIsObscured
kScopesRoute
kNamesRoute
kIsHidden
kIsImage
kIsLiveRegion
kHasToggledState
kIsToggled
kHasImplicitScrolling
kIsMultiline
kIsReadOnly
kIsFocusable
kIsLink
kIsSlider
kIsKeyboardKey
kIsCheckStateMixed
kHasExpandedState
kIsExpanded

Definition at line 65 of file semantics_node.h.

                          : 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,
};

StringAttributeType

enum class flutter::StringAttributeType : int32_t

strong

Enumerator
kSpellOut
kLocale

Definition at line 27 of file string_attribute.h.

                               : int32_t {
  kSpellOut,
  kLocale,
};

TracingResult

enum class flutter::TracingResult

strong

Enumerator
kNotAttempted
kEnabled
kNotNecessary
kDisabled

Definition at line 17 of file ptrace_check.h.

                         {
  kNotAttempted,
  kEnabled,
  kNotNecessary = kEnabled,
  kDisabled,
};

WindowStateEvent

enum class flutter::WindowStateEvent

strong

An event representing a change in window state that may update the.

Enumerator
kShow
kHide
kFocus
kUnfocus

Definition at line 24 of file windows_lifecycle_manager.h.

                            {
  kShow,
  kHide,
  kFocus,
  kUnfocus,
};

Function Documentation

__attribute__()

struct flutter::ImageMetaData flutter::__attribute__

(

(packed)

)

AndroidPlatformThreadConfigSetter()

static void flutter::AndroidPlatformThreadConfigSetter ( const fml::Thread::ThreadConfig &  config )

static

Inheriting ThreadConfigurer and use Android platform thread API to configure the thread priorities

Definition at line 38 of file android_shell_holder.cc.

                                         {
  // set thread name
  fml::Thread::SetCurrentThreadName(config);
  // set thread priority
  switch (config.priority) {
    case fml::Thread::ThreadPriority::kBackground: {
      fml::RequestAffinity(fml::CpuAffinity::kEfficiency);
      if (::setpriority(PRIO_PROCESS, 0, 10) != 0) {
        FML_LOG(ERROR) << "Failed to set IO task runner priority";
      }
      break;
    }
    case fml::Thread::ThreadPriority::kDisplay: {
      fml::RequestAffinity(fml::CpuAffinity::kPerformance);
      if (::setpriority(PRIO_PROCESS, 0, -1) != 0) {
        FML_LOG(ERROR) << "Failed to set UI task runner priority";
      }
      break;
    }
    case fml::Thread::ThreadPriority::kRaster: {
      fml::RequestAffinity(fml::CpuAffinity::kPerformance);
      // Android describes -8 as "most important display threads, for
      // compositing the screen and retrieving input events". Conservatively
      // set the raster thread to slightly lower priority than it.
      if (::setpriority(PRIO_PROCESS, 0, -5) != 0) {
        // Defensive fallback. Depending on the OEM, it may not be possible
        // to set priority to -5.
        if (::setpriority(PRIO_PROCESS, 0, -2) != 0) {
          FML_LOG(ERROR) << "Failed to set raster task runner priority";
        }
      }
      break;
    }
    default:
      fml::RequestAffinity(fml::CpuAffinity::kNotPerformance);
      if (::setpriority(PRIO_PROCESS, 0, 0) != 0) {
        FML_LOG(ERROR) << "Failed to set priority";
      }
  }
}

AppLifecycleStateToString()

constexpr const char * flutter::AppLifecycleStateToString ( AppLifecycleState  state )

constexpr

Definition at line 72 of file app_lifecycle_state.h.

                                                                         {
  switch (state) {
    case AppLifecycleState::kDetached:
      return "AppLifecycleState.detached";
    case AppLifecycleState::kResumed:
      return "AppLifecycleState.resumed";
    case AppLifecycleState::kInactive:
      return "AppLifecycleState.inactive";
    case AppLifecycleState::kHidden:
      return "AppLifecycleState.hidden";
    case AppLifecycleState::kPaused:
      return "AppLifecycleState.paused";
  }
}

AttachJNI()

static jlong flutter::AttachJNI ( JNIEnv *  env, jclass  clazz, jobject  flutterJNI  )

static

Definition at line 158 of file platform_view_android_jni_impl.cc.

                                                                      {
  fml::jni::JavaObjectWeakGlobalRef java_object(env, flutterJNI);
  std::shared_ptr<PlatformViewAndroidJNI> jni_facade =
      std::make_shared<PlatformViewAndroidJNIImpl>(java_object);
  auto shell_holder = std::make_unique<AndroidShellHolder>(
      FlutterMain::Get().GetSettings(), jni_facade);
  if (shell_holder->IsValid()) {
    return reinterpret_cast<jlong>(shell_holder.release());
  } else {
    return 0;
  }
}

BENCHMARK() [1/4]

flutter::BENCHMARK

(

BM_PathVolatilityTracker

)

-> Unit(benchmark::kMillisecond)

BENCHMARK() [2/4]

flutter::BENCHMARK

(

BM_ShellInitialization

)

BENCHMARK() [3/4]

flutter::BENCHMARK

(

BM_ShellInitializationAndShutdown

)

BENCHMARK() [4/4]

flutter::BENCHMARK

(

BM_ShellShutdown

)

BENCHMARK_CAPTURE() [1/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderDefault	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [2/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderDefault	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [3/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderDefault	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [4/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderDefault	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [5/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithClipRect	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [6/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithClipRect	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [7/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithClipRect	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [8/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithClipRect	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [9/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithGlobalSaveLayer	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [10/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithGlobalSaveLayer	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [11/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithGlobalSaveLayer	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [12/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithGlobalSaveLayer	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [13/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithPerspective	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [14/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithPerspective	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [15/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithPerspective	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [16/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithPerspective	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [17/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayer	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [18/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayer	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [19/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayer	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [20/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayer	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [21/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayerAndImageFilter	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [22/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayerAndImageFilter	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [23/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayerAndImageFilter	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [24/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithSaveLayerAndImageFilter	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [25/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithScaleAndTranslate	,
		kBounds	,
		DisplayListBuilderBenchmarkType::kBounds
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [26/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithScaleAndTranslate	,
		kBoundsAndRtree	,
		DisplayListBuilderBenchmarkType::kBoundsAndRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [27/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithScaleAndTranslate	,
		kDefault	,
		DisplayListBuilderBenchmarkType::kDefault
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [28/76]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListBuilderWithScaleAndTranslate	,
		kRtree	,
		DisplayListBuilderBenchmarkType::kRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [29/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_IntersectsRegion	,
		LargeAsymmetric	,
		1500	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [30/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_IntersectsRegion	,
		MediumAsymmetric	,
		400	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [31/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_IntersectsRegion	,
		SmallAsymmetric	,
		100	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [32/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_IntersectsRegion	,
		TinyAsymmetric	,
		30	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [33/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_Large	,
		RegionOp::kIntersection	,
		false	,
		1500	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [34/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_LargeAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		1500	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [35/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_Medium	,
		RegionOp::kIntersection	,
		false	,
		400	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [36/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_MediumAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		400	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [37/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_SingleRect_Large	,
		RegionOp::kIntersection	,
		true	,
		1500	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [38/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_SingleRect_Medium	,
		RegionOp::kIntersection	,
		true	,
		400	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [39/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_SingleRect_Small	,
		RegionOp::kIntersection	,
		true	,
		100	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [40/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_SingleRect_Tiny	,
		RegionOp::kIntersection	,
		true	,
		30	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [41/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_Small	,
		RegionOp::kIntersection	,
		false	,
		100	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [42/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_SmallAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		100	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [43/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_Tiny	,
		RegionOp::kIntersection	,
		false	,
		30	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [44/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Intersection_TinyAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		30	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [45/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_Large	,
		RegionOp::kUnion	,
		false	,
		1500	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [46/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_LargeAsymmetric	,
		RegionOp::kUnion	,
		false	,
		1500	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [47/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_Medium	,
		RegionOp::kUnion	,
		false	,
		400	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [48/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_MediumAsymmetric	,
		RegionOp::kUnion	,
		false	,
		400	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [49/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_Small	,
		RegionOp::kUnion	,
		false	,
		100	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [50/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_SmallAsymmetric	,
		RegionOp::kUnion	,
		false	,
		100	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [51/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_Tiny	,
		RegionOp::kUnion	,
		false	,
		30	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [52/76]

flutter::BENCHMARK_CAPTURE	(	BM_DlRegion_Operation	,
		Union_TinyAsymmetric	,
		RegionOp::kUnion	,
		false	,
		30	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [53/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_IntersectsRegion	,
		LargeAsymmetric	,
		1500	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [54/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_IntersectsRegion	,
		MediumAsymmetric	,
		400	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [55/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_IntersectsRegion	,
		SmallAsymmetric	,
		100	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [56/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_IntersectsRegion	,
		TinyAsymmetric	,
		30	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kNanosecond)

BENCHMARK_CAPTURE() [57/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_Large	,
		RegionOp::kIntersection	,
		false	,
		1500	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [58/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_LargeAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		1500	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [59/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_Medium	,
		RegionOp::kIntersection	,
		false	,
		400	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [60/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_MediumAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		400	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [61/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_SingleRect_Large	,
		RegionOp::kIntersection	,
		true	,
		1500	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [62/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_SingleRect_Medium	,
		RegionOp::kIntersection	,
		true	,
		400	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [63/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_SingleRect_Small	,
		RegionOp::kIntersection	,
		true	,
		100	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [64/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_SingleRect_Tiny	,
		RegionOp::kIntersection	,
		true	,
		30	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [65/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_Small	,
		RegionOp::kIntersection	,
		false	,
		100	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [66/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_SmallAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		100	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [67/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_Tiny	,
		RegionOp::kIntersection	,
		false	,
		30	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [68/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Intersection_TinyAsymmetric	,
		RegionOp::kIntersection	,
		false	,
		30	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [69/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_Large	,
		RegionOp::kUnion	,
		false	,
		1500	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [70/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_LargeAsymmetric	,
		RegionOp::kUnion	,
		false	,
		1500	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [71/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_Medium	,
		RegionOp::kUnion	,
		false	,
		400	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [72/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_MediumAsymmetric	,
		RegionOp::kUnion	,
		false	,
		400	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [73/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_Small	,
		RegionOp::kUnion	,
		false	,
		100	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [74/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_SmallAsymmetric	,
		RegionOp::kUnion	,
		false	,
		100	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [75/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_Tiny	,
		RegionOp::kUnion	,
		false	,
		30	,
		1.	0
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [76/76]

flutter::BENCHMARK_CAPTURE	(	BM_SkRegion_Operation	,
		Union_TinyAsymmetric	,
		RegionOp::kUnion	,
		false	,
		30	,
		kSizeFactorSmall
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE_ALL() [1/3]

flutter::BENCHMARK_CAPTURE_ALL

(

BM_AdapterDispatchOverhead

)

BENCHMARK_CAPTURE_ALL() [2/3]

flutter::BENCHMARK_CAPTURE_ALL

(

BM_SetIdentity

)

BENCHMARK_CAPTURE_ALL() [3/3]

flutter::BENCHMARK_CAPTURE_ALL

(

BM_SetPerspective

)

BENCHMARK_CAPTURE_ALL_ARGS() [1/3]

flutter::BENCHMARK_CAPTURE_ALL_ARGS	(	BM_Rotate	,
		kPiOver4
	)

BENCHMARK_CAPTURE_ALL_ARGS() [2/3]

flutter::BENCHMARK_CAPTURE_ALL_ARGS	(	BM_Scale	,
		2.	0f
	)

BENCHMARK_CAPTURE_ALL_ARGS() [3/3]

flutter::BENCHMARK_CAPTURE_ALL_ARGS	(	BM_Translate	,
		10.	0f,
		15.	0f
	)

BENCHMARK_CAPTURE_ALL_SETUP() [1/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertAndCheck	,
		Identity
	)

BENCHMARK_CAPTURE_ALL_SETUP() [2/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertAndCheck	,
		Perspective
	)

BENCHMARK_CAPTURE_ALL_SETUP() [3/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertAndCheck	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [4/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertAndCheck	,
		Scale
	)

BENCHMARK_CAPTURE_ALL_SETUP() [5/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertAndCheck	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [6/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertAndCheck	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [7/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertUnchecked	,
		Identity
	)

BENCHMARK_CAPTURE_ALL_SETUP() [8/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertUnchecked	,
		Perspective
	)

BENCHMARK_CAPTURE_ALL_SETUP() [9/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertUnchecked	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [10/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertUnchecked	,
		Scale
	)

BENCHMARK_CAPTURE_ALL_SETUP() [11/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertUnchecked	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [12/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_InvertUnchecked	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [13/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		Identity
	)

BENCHMARK_CAPTURE_ALL_SETUP() [14/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		PerspectiveClipFour
	)

BENCHMARK_CAPTURE_ALL_SETUP() [15/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		PerspectiveClipNone
	)

BENCHMARK_CAPTURE_ALL_SETUP() [16/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		PerspectiveClipOne
	)

BENCHMARK_CAPTURE_ALL_SETUP() [17/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		PerspectiveClipThree
	)

BENCHMARK_CAPTURE_ALL_SETUP() [18/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		PerspectiveClipTwo
	)

BENCHMARK_CAPTURE_ALL_SETUP() [19/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [20/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		Scale
	)

BENCHMARK_CAPTURE_ALL_SETUP() [21/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [22/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformAndClipRect	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [23/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoint	,
		Identity
	)

BENCHMARK_CAPTURE_ALL_SETUP() [24/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoint	,
		Perspective
	)

BENCHMARK_CAPTURE_ALL_SETUP() [25/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoint	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [26/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoint	,
		Scale
	)

BENCHMARK_CAPTURE_ALL_SETUP() [27/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoint	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [28/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoint	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [29/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoints	,
		Identity
	)

BENCHMARK_CAPTURE_ALL_SETUP() [30/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoints	,
		Perspective
	)

BENCHMARK_CAPTURE_ALL_SETUP() [31/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoints	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [32/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoints	,
		Scale
	)

BENCHMARK_CAPTURE_ALL_SETUP() [33/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoints	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [34/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformPoints	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [35/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		Identity
	)

BENCHMARK_CAPTURE_ALL_SETUP() [36/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		PerspectiveClipFour
	)

BENCHMARK_CAPTURE_ALL_SETUP() [37/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		PerspectiveClipNone
	)

BENCHMARK_CAPTURE_ALL_SETUP() [38/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		PerspectiveClipOne
	)

BENCHMARK_CAPTURE_ALL_SETUP() [39/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		PerspectiveClipThree
	)

BENCHMARK_CAPTURE_ALL_SETUP() [40/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		PerspectiveClipTwo
	)

BENCHMARK_CAPTURE_ALL_SETUP() [41/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [42/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		Scale
	)

BENCHMARK_CAPTURE_ALL_SETUP() [43/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP() [44/44]

flutter::BENCHMARK_CAPTURE_ALL_SETUP	(	BM_TransformRectFast	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP2() [1/5]

flutter::BENCHMARK_CAPTURE_ALL_SETUP2	(	BM_Concat	,
		Perspective	,
		ScaleTranslate
	)

BENCHMARK_CAPTURE_ALL_SETUP2() [2/5]

flutter::BENCHMARK_CAPTURE_ALL_SETUP2	(	BM_Concat	,
		Scale	,
		Translate
	)

BENCHMARK_CAPTURE_ALL_SETUP2() [3/5]

flutter::BENCHMARK_CAPTURE_ALL_SETUP2	(	BM_Concat	,
		ScaleTranslate	,
		Perspective
	)

BENCHMARK_CAPTURE_ALL_SETUP2() [4/5]

flutter::BENCHMARK_CAPTURE_ALL_SETUP2	(	BM_Concat	,
		ScaleTranslate	,
		Rotate
	)

BENCHMARK_CAPTURE_ALL_SETUP2() [5/5]

flutter::BENCHMARK_CAPTURE_ALL_SETUP2	(	BM_Concat	,
		ScaleTranslate	,
		ScaleTranslate
	)

BlurRadiusEqualToBlurRadius()

BOOL flutter::BlurRadiusEqualToBlurRadius	(	CGFloat	radius1,
		CGFloat	radius2
	)

Definition at line 69 of file FlutterPlatformViews_Internal.mm.

                                                                   {
  const CGFloat epsilon = 0.01;
  return radius1 - radius2 < epsilon;
}

BM_AdapterDispatchOverhead()

static void flutter::BM_AdapterDispatchOverhead ( benchmark::State &  state, AdapterType  type  )

static

Definition at line 577 of file dl_transform_benchmarks.cc.

                                                         {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  while (state.KeepRunning()) {
    adapter->DoNothing(transform);
  }
}

BM_Concat()

static void flutter::BM_Concat ( benchmark::State &  state, AdapterType  type, const SetupFunction &  a_setup, const SetupFunction &  b_setup  )

static

Definition at line 647 of file dl_transform_benchmarks.cc.

                                                    {
  auto adapter = GetAdapter(type);
  TestTransform a, b, result;
  a_setup(adapter.get(), a, nullptr);
  b_setup(adapter.get(), b, nullptr);
  while (state.KeepRunning()) {
    adapter->Concat(a, b, result);
  }
}

BM_DisplayListBuilderDefault()

static void flutter::BM_DisplayListBuilderDefault ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 62 of file dl_builder_benchmarks.cc.

                                                                               {
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    InvokeAllRenderingOps(builder);
    Complete(builder, type);
  }
}

BM_DisplayListBuilderWithClipRect()

static void flutter::BM_DisplayListBuilderWithClipRect ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 98 of file dl_builder_benchmarks.cc.

                                          {
  SkRect clip_bounds = SkRect::MakeLTRB(6.5, 7.3, 90.2, 85.7);
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    builder.ClipRect(clip_bounds, DlCanvas::ClipOp::kIntersect, true);
    InvokeAllRenderingOps(builder);
    Complete(builder, type);
  }
}

BM_DisplayListBuilderWithGlobalSaveLayer()

static void flutter::BM_DisplayListBuilderWithGlobalSaveLayer ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 111 of file dl_builder_benchmarks.cc.

                                          {
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    builder.Scale(3.5, 3.5);
    builder.Translate(10.3, 6.9);
    builder.SaveLayer(nullptr, nullptr);
    builder.Translate(45.3, 27.9);
    DlOpReceiver& receiver = DisplayListBuilderBenchmarkAccessor(builder);
    for (auto& group : allRenderingOps) {
      for (size_t i = 0; i < group.variants.size(); i++) {
        auto& invocation = group.variants[i];
        invocation.Invoke(receiver);
      }
    }
    builder.Restore();
    Complete(builder, type);
  }
}

BM_DisplayListBuilderWithPerspective()

static void flutter::BM_DisplayListBuilderWithPerspective ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 85 of file dl_builder_benchmarks.cc.

                                          {
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    builder.TransformFullPerspective(0, 1, 0, 12, 1, 0, 0, 33, 3, 2, 5, 29, 0,
                                     0, 0, 12);
    InvokeAllRenderingOps(builder);
    Complete(builder, type);
  }
}

BM_DisplayListBuilderWithSaveLayer()

static void flutter::BM_DisplayListBuilderWithSaveLayer ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 133 of file dl_builder_benchmarks.cc.

                                          {
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    DlOpReceiver& receiver = DisplayListBuilderBenchmarkAccessor(builder);
    for (auto& group : allRenderingOps) {
      for (size_t i = 0; i < group.variants.size(); i++) {
        auto& invocation = group.variants[i];
        builder.SaveLayer(nullptr, nullptr);
        invocation.Invoke(receiver);
        builder.Restore();
      }
    }
    Complete(builder, type);
  }
}

BM_DisplayListBuilderWithSaveLayerAndImageFilter()

static void flutter::BM_DisplayListBuilderWithSaveLayerAndImageFilter ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 152 of file dl_builder_benchmarks.cc.

                                          {
  DlPaint layer_paint;
  layer_paint.setImageFilter(&testing::kTestBlurImageFilter1);
  SkRect layer_bounds = SkRect::MakeLTRB(6.5, 7.3, 35.2, 42.7);
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    DlOpReceiver& receiver = DisplayListBuilderBenchmarkAccessor(builder);
    for (auto& group : allRenderingOps) {
      for (size_t i = 0; i < group.variants.size(); i++) {
        auto& invocation = group.variants[i];
        builder.SaveLayer(&layer_bounds, &layer_paint);
        invocation.Invoke(receiver);
        builder.Restore();
      }
    }
    Complete(builder, type);
  }
}

BM_DisplayListBuilderWithScaleAndTranslate()

static void flutter::BM_DisplayListBuilderWithScaleAndTranslate ( benchmark::State &  state, DisplayListBuilderBenchmarkType  type  )

static

Definition at line 72 of file dl_builder_benchmarks.cc.

                                          {
  bool prepare_rtree = NeedPrepareRTree(type);
  while (state.KeepRunning()) {
    DisplayListBuilder builder(prepare_rtree);
    builder.Scale(3.5, 3.5);
    builder.Translate(10.3, 6.9);
    InvokeAllRenderingOps(builder);
    Complete(builder, type);
  }
}

BM_DlRegion_FromRects()

static void flutter::BM_DlRegion_FromRects ( benchmark::State &  state, int  maxSize  )

static

Definition at line 260 of file dl_region_benchmarks.cc.

                                                                      {
  RunFromRectsBenchmark<DlRegionAdapter>(state, maxSize);
}

BM_DlRegion_GetRects()

static void flutter::BM_DlRegion_GetRects ( benchmark::State &  state, int  maxSize  )

static

Definition at line 268 of file dl_region_benchmarks.cc.

                                                                     {
  RunGetRectsBenchmark<DlRegionAdapter>(state, maxSize);
}

BM_DlRegion_IntersectsRegion()

static void flutter::BM_DlRegion_IntersectsRegion ( benchmark::State &  state, int  maxSize, double  sizeFactor  )

static

Definition at line 294 of file dl_region_benchmarks.cc.

                                                            {
  RunIntersectsRegionBenchmark<DlRegionAdapter>(state, maxSize, sizeFactor);
}

BM_DlRegion_IntersectsSingleRect()

static void flutter::BM_DlRegion_IntersectsSingleRect ( benchmark::State &  state, int  maxSize  )

static

Definition at line 306 of file dl_region_benchmarks.cc.

                                                          {
  RunIntersectsSingleRectBenchmark<DlRegionAdapter>(state, maxSize);
}

BM_DlRegion_Operation()

static void flutter::BM_DlRegion_Operation ( benchmark::State &  state, RegionOp  op, bool  withSingleRect, int  maxSize, double  sizeFactor  )

static

Definition at line 276 of file dl_region_benchmarks.cc.

                                                     {
  RunRegionOpBenchmark<DlRegionAdapter>(state, op, withSingleRect, maxSize,
                                        sizeFactor);
}

BM_InvertAndCheck()

static void flutter::BM_InvertAndCheck ( benchmark::State &  state, AdapterType  type, const SetupFunction &  setup  )

static

Definition at line 737 of file dl_transform_benchmarks.cc.

                                                          {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  setup(adapter.get(), transform, nullptr);
  TestTransform result;
  while (state.KeepRunning()) {
    adapter->InvertAndCheck(transform, result);
  }
}

BM_InvertUnchecked()

static void flutter::BM_InvertUnchecked ( benchmark::State &  state, AdapterType  type, const SetupFunction &  setup  )

static

Definition at line 725 of file dl_transform_benchmarks.cc.

                                                           {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  setup(adapter.get(), transform, nullptr);
  TestTransform result;
  while (state.KeepRunning()) {
    adapter->InvertUnchecked(transform, result);
  }
}

BM_PathVolatilityTracker()

static void flutter::BM_PathVolatilityTracker ( benchmark::State &  state )

static

Definition at line 70 of file ui_benchmarks.cc.

                                                            {
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "test", ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
                  ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  VolatilePathTracker tracker(task_runners.GetUITaskRunner(), true);
 
  while (state.KeepRunning()) {
    std::vector<std::shared_ptr<VolatilePathTracker::TrackedPath>> paths;
    constexpr int path_count = 1000;
    for (int i = 0; i < path_count; i++) {
      auto path = std::make_shared<VolatilePathTracker::TrackedPath>();
      path->path = SkPath();
      path->path.setIsVolatile(true);
      paths.push_back(std::move(path));
    }
 
    fml::AutoResetWaitableEvent latch;
    task_runners.GetUITaskRunner()->PostTask([&]() {
      for (const auto& path : paths) {
        tracker.Track(path);
      }
      latch.Signal();
    });
 
    latch.Wait();
 
    task_runners.GetUITaskRunner()->PostTask([&]() { tracker.OnFrame(); });
 
    for (int i = 0; i < path_count - 10; ++i) {
      paths[i].reset();
    }
 
    task_runners.GetUITaskRunner()->PostTask([&]() { tracker.OnFrame(); });
 
    latch.Reset();
    task_runners.GetUITaskRunner()->PostTask([&]() { latch.Signal(); });
    latch.Wait();
  }
}

BM_PlatformMessageResponseDartComplete()

static void flutter::BM_PlatformMessageResponseDartComplete ( benchmark::State &  state )

static

Definition at line 22 of file ui_benchmarks.cc.

                                                                          {
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "test", ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
                  ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  Fixture fixture;
  auto settings = fixture.CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto isolate =
      testing::RunDartCodeInIsolate(vm_ref, settings, task_runners, "main", {},
                                    testing::GetDefaultKernelFilePath(), {});
 
  while (state.KeepRunning()) {
    state.PauseTiming();
    bool successful = isolate->RunInIsolateScope([&]() -> bool {
      // Simulate a message of 3 MB
      std::vector<uint8_t> data(3 << 20, 0);
      std::unique_ptr<fml::Mapping> mapping =
          std::make_unique<fml::DataMapping>(data);
 
      Dart_Handle library = Dart_RootLibrary();
      Dart_Handle closure =
          Dart_GetField(library, Dart_NewStringFromCString("messageCallback"));
 
      auto message = fml::MakeRefCounted<PlatformMessageResponseDart>(
          tonic::DartPersistentValue(isolate->get(), closure),
          thread_host.ui_thread->GetTaskRunner(), "");
 
      message->Complete(std::move(mapping));
 
      return true;
    });
    FML_CHECK(successful);
    state.ResumeTiming();
 
    // We skip timing everything above because the copy triggered by
    // message->Complete is a task posted on the UI thread. The following wait
    // for a UI task would let us know when that copy is done.
    std::promise<bool> completed;
    task_runners.GetUITaskRunner()->PostTask(
        [&completed] { completed.set_value(true); });
    completed.get_future().wait();
  }
}

BM_Rotate()

static void flutter::BM_Rotate ( benchmark::State &  state, AdapterType  type, float  radians  )

static

Definition at line 636 of file dl_transform_benchmarks.cc.

                                     {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  adapter->InitTransformIdentity(transform);
  while (state.KeepRunning()) {
    adapter->RotateRadians(transform, radians);
  }
}

BM_Scale()

static void flutter::BM_Scale ( benchmark::State &  state, AdapterType  type, float  scale  )

static

Definition at line 620 of file dl_transform_benchmarks.cc.

                                                                           {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  adapter->InitTransformIdentity(transform);
  float inv_scale = 1.0f / scale;
  bool flip = true;
  while (state.KeepRunning()) {
    if (flip) {
      adapter->Scale(transform, scale, scale);
    } else {
      adapter->Scale(transform, inv_scale, inv_scale);
    }
    flip = !flip;
  }
}

BM_SetIdentity()

static void flutter::BM_SetIdentity ( benchmark::State &  state, AdapterType  type  )

static

Definition at line 586 of file dl_transform_benchmarks.cc.

                                                                    {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  while (state.KeepRunning()) {
    adapter->InitTransformIdentity(transform);
  }
}

BM_SetPerspective()

static void flutter::BM_SetPerspective ( benchmark::State &  state, AdapterType  type  )

static

Definition at line 594 of file dl_transform_benchmarks.cc.

                                                                       {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  while (state.KeepRunning()) {
    adapter->InitTransformColMatrix(transform, kSimplePerspective);
  }
}

BM_ShellInitialization()

static void flutter::BM_ShellInitialization ( benchmark::State &  state )

static

Definition at line 99 of file shell_benchmarks.cc.

                                                          {
  while (state.KeepRunning()) {
    StartupAndShutdownShell(state, true, false);
  }
}

BM_ShellInitializationAndShutdown()

static void flutter::BM_ShellInitializationAndShutdown ( benchmark::State &  state )

static

Definition at line 115 of file shell_benchmarks.cc.

                                                                     {
  while (state.KeepRunning()) {
    StartupAndShutdownShell(state, true, true);
  }
}

BM_ShellShutdown()

static void flutter::BM_ShellShutdown ( benchmark::State &  state )

static

Definition at line 107 of file shell_benchmarks.cc.

                                                    {
  while (state.KeepRunning()) {
    StartupAndShutdownShell(state, false, true);
  }
}

BM_SkRegion_FromRects()

static void flutter::BM_SkRegion_FromRects ( benchmark::State &  state, int  maxSize  )

static

Definition at line 264 of file dl_region_benchmarks.cc.

                                                                      {
  RunFromRectsBenchmark<SkRegionAdapter>(state, maxSize);
}

BM_SkRegion_GetRects()

static void flutter::BM_SkRegion_GetRects ( benchmark::State &  state, int  maxSize  )

static

Definition at line 272 of file dl_region_benchmarks.cc.

                                                                     {
  RunGetRectsBenchmark<SkRegionAdapter>(state, maxSize);
}

BM_SkRegion_IntersectsRegion()

static void flutter::BM_SkRegion_IntersectsRegion ( benchmark::State &  state, int  maxSize, double  sizeFactor  )

static

Definition at line 300 of file dl_region_benchmarks.cc.

                                                            {
  RunIntersectsRegionBenchmark<SkRegionAdapter>(state, maxSize, sizeFactor);
}

BM_SkRegion_IntersectsSingleRect()

static void flutter::BM_SkRegion_IntersectsSingleRect ( benchmark::State &  state, int  maxSize  )

static

Definition at line 311 of file dl_region_benchmarks.cc.

                                                          {
  RunIntersectsSingleRectBenchmark<SkRegionAdapter>(state, maxSize);
}

BM_SkRegion_Operation()

static void flutter::BM_SkRegion_Operation ( benchmark::State &  state, RegionOp  op, bool  withSingleRect, int  maxSize, double  sizeFactor  )

static

Definition at line 285 of file dl_region_benchmarks.cc.

                                                     {
  RunRegionOpBenchmark<SkRegionAdapter>(state, op, withSingleRect, maxSize,
                                        sizeFactor);
}

BM_TransformAndClipRect()

static void flutter::BM_TransformAndClipRect ( benchmark::State &  state, AdapterType  type, const SetupFunction &  setup  )

static

Definition at line 712 of file dl_transform_benchmarks.cc.

                                                                {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  TestRect rect, result;
  adapter->InitRectLTRB(rect, 100, 100, 200, 200);
  setup(adapter.get(), transform, &rect);
  while (state.KeepRunning()) {
    adapter->TransformAndClipRect(transform, rect, result);
  }
}

BM_TransformPoint()

static void flutter::BM_TransformPoint ( benchmark::State &  state, AdapterType  type, const SetupFunction &  setup  )

static

Definition at line 660 of file dl_transform_benchmarks.cc.

                                                          {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  setup(adapter.get(), transform, nullptr);
  TestPoint point, result;
  adapter->InitPoint(point, 25.7, 32.4);
  while (state.KeepRunning()) {
    adapter->TransformPoint(transform, point, result);
  }
}

BM_TransformPoints()

static void flutter::BM_TransformPoints ( benchmark::State &  state, AdapterType  type, const SetupFunction &  setup  )

static

Definition at line 673 of file dl_transform_benchmarks.cc.

                                                           {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  setup(adapter.get(), transform, nullptr);
  const int Xs = 10;
  const int Ys = 10;
  const int N = Xs * Ys;
  TestPoint points[N];
  for (int i = 0; i < Xs; i++) {
    for (int j = 0; j < Ys; j++) {
      int index = i * Xs + j;
      FML_CHECK(index < N);
      adapter->InitPoint(points[index], i * 23.3 + 17, j * 32.7 + 12);
    }
  }
  TestPoint results[N];
  int64_t item_count = 0;
  while (state.KeepRunning()) {
    adapter->TransformPoints(transform, points, results, N);
    item_count += N;
  }
  state.SetItemsProcessed(item_count);
}

BM_TransformRectFast()

static void flutter::BM_TransformRectFast ( benchmark::State &  state, AdapterType  type, const SetupFunction &  setup  )

static

Definition at line 699 of file dl_transform_benchmarks.cc.

                                                             {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  TestRect rect, result;
  adapter->InitRectLTRB(rect, 100, 100, 200, 200);
  setup(adapter.get(), transform, &rect);
  while (state.KeepRunning()) {
    adapter->TransformRectFast(transform, rect, result);
  }
}

BM_Translate()

static void flutter::BM_Translate ( benchmark::State &  state, AdapterType  type, float  tx, float  ty  )

static

Definition at line 602 of file dl_transform_benchmarks.cc.

                                   {
  auto adapter = GetAdapter(type);
  TestTransform transform;
  adapter->InitTransformIdentity(transform);
  bool flip = true;
  while (state.KeepRunning()) {
    if (flip) {
      adapter->Translate(transform, tx, ty);
    } else {
      adapter->Translate(transform, -tx, -ty);
    }
    flip = !flip;
  }
}

bytes_needed()

static size_t flutter::bytes_needed ( int  vertex_count, Flags  flags, int  index_count  )

static

Definition at line 23 of file dl_vertices.cc.

                                                                           {
  int needed = sizeof(DlVertices);
  // We always have vertices
  needed += vertex_count * sizeof(SkPoint);
  if (flags.has_texture_coordinates) {
    needed += vertex_count * sizeof(SkPoint);
  }
  if (flags.has_colors) {
    needed += vertex_count * sizeof(DlColor);
  }
  if (index_count > 0) {
    needed += index_count * sizeof(uint16_t);
  }
  return needed;
}

CastToMetalContext()

static IOSContextMetalSkia * flutter::CastToMetalContext ( const std::shared_ptr< IOSContext > &  context )

static

Definition at line 21 of file ios_surface_metal_skia.mm.

                                         {
  return (IOSContextMetalSkia*)context.get();
}

CheckEncodeDecode()

static void flutter::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

Definition at line 37 of file standard_message_codec_unittests.cc.

                                     {
  const StandardMessageCodec& codec =
      StandardMessageCodec::GetInstance(serializer);
  auto encoded = codec.EncodeMessage(value);
  ASSERT_TRUE(encoded);
  EXPECT_EQ(*encoded, expected_encoding);
 
  auto decoded = codec.DecodeMessage(*encoded);
  if (custom_comparator) {
    EXPECT_TRUE(custom_comparator(value, *decoded));
  } else {
    EXPECT_EQ(value, *decoded);
  }
}

CheckEncodeDecodeWithEncodePrefix()

static void flutter::CheckEncodeDecodeWithEncodePrefix ( const EncodableValue &  value, const std::vector< uint8_t > &  expected_encoding_prefix, size_t  expected_encoding_length  )

static

Definition at line 62 of file standard_message_codec_unittests.cc.

                                     {
  EXPECT_TRUE(std::holds_alternative<EncodableMap>(value));
  const StandardMessageCodec& codec = StandardMessageCodec::GetInstance();
  auto encoded = codec.EncodeMessage(value);
  ASSERT_TRUE(encoded);
 
  EXPECT_EQ(encoded->size(), expected_encoding_length);
  ASSERT_GT(encoded->size(), expected_encoding_prefix.size());
  EXPECT_TRUE(std::equal(
      encoded->begin(), encoded->begin() + expected_encoding_prefix.size(),
      expected_encoding_prefix.begin(), expected_encoding_prefix.end()));
 
  auto decoded = codec.DecodeMessage(*encoded);
 
  EXPECT_EQ(value, *decoded);
}

ChooseCompatibleAlphaType()

static SkAlphaType flutter::ChooseCompatibleAlphaType ( SkAlphaType  type )

static

Definition at line 107 of file image_decoder_impeller.cc.

                                                               {
  return type;
}

ChooseCompatibleColorType()

static SkColorType flutter::ChooseCompatibleColorType ( SkColorType  type )

static

Definition at line 98 of file image_decoder_impeller.cc.

                                                               {
  switch (type) {
    case kRGBA_F32_SkColorType:
      return kRGBA_F16_SkColorType;
    default:
      return kRGBA_8888_SkColorType;
  }
}

ChooseEGLConfiguration()

static EGLResult< EGLConfig > flutter::ChooseEGLConfiguration ( EGLDisplay  display )

static

Definition at line 27 of file android_context_gl_skia.cc.

                                                                       {
  EGLint attributes[] = {
      // clang-format off
      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
      EGL_SURFACE_TYPE,    EGL_WINDOW_BIT,
      EGL_RED_SIZE,        8,
      EGL_GREEN_SIZE,      8,
      EGL_BLUE_SIZE,       8,
      EGL_ALPHA_SIZE,      8,
      EGL_DEPTH_SIZE,      0,
      EGL_STENCIL_SIZE,    0,
      EGL_NONE,            // termination sentinel
      // clang-format on
  };
 
  EGLint config_count = 0;
  EGLConfig egl_config = nullptr;
 
  if (eglChooseConfig(display, attributes, &egl_config, 1, &config_count) !=
      EGL_TRUE) {
    return {false, nullptr};
  }
 
  bool success = config_count > 0 && egl_config != nullptr;
 
  return {success, success ? egl_config : nullptr};
}

CleanupMessageData()

static void flutter::CleanupMessageData ( JNIEnv *  env, jobject  jcaller, jlong  message_data  )

static

Definition at line 435 of file platform_view_android_jni_impl.cc.

                                                   {
  // Called from any thread.
  free(reinterpret_cast<void*>(message_data));
}

Close()

API void flutter::Close

(

SkPath *

path

)

Definition at line 36 of file path_ops.cc.

                         {
  path->close();
}

CommandLineFromNSProcessInfo()

fml::CommandLine flutter::CommandLineFromNSProcessInfo

(

NSProcessInfo *

processInfoOrNil = nil

)

Definition at line 11 of file command_line.mm.

                                                                             {
  std::vector<std::string> args_vector;
  auto processInfo = processInfoOrNil ? processInfoOrNil : [NSProcessInfo processInfo];
 
  for (NSString* arg in processInfo.arguments) {
    args_vector.emplace_back(arg.UTF8String);
  }
 
  return fml::CommandLineFromIterators(args_vector.begin(), args_vector.end());
}

CompareOps()

static bool flutter::CompareOps ( const uint8_t *  ptrA, const uint8_t *  endA, const uint8_t *  ptrB, const uint8_t *  endB  )

static

Definition at line 243 of file display_list.cc.

                                            {
  // These conditions are checked by the caller...
  FML_DCHECK((endA - ptrA) == (endB - ptrB));
  FML_DCHECK(ptrA != ptrB);
  const uint8_t* bulk_start_a = ptrA;
  const uint8_t* bulk_start_b = ptrB;
  while (ptrA < endA && ptrB < endB) {
    auto opA = reinterpret_cast<const DLOp*>(ptrA);
    auto opB = reinterpret_cast<const DLOp*>(ptrB);
    if (opA->type != opB->type || opA->size != opB->size) {
      return false;
    }
    ptrA += opA->size;
    ptrB += opB->size;
    FML_DCHECK(ptrA <= endA);
    FML_DCHECK(ptrB <= endB);
    DisplayListCompare result;
    switch (opA->type) {
#define DL_OP_EQUALS(name)                              \
  case DisplayListOpType::k##name:                      \
    result = static_cast<const name##Op*>(opA)->equals( \
        static_cast<const name##Op*>(opB));             \
    break;
 
      FOR_EACH_DISPLAY_LIST_OP(DL_OP_EQUALS)
#ifdef IMPELLER_ENABLE_3D
      DL_OP_EQUALS(SetSceneColorSource)
#endif  // IMPELLER_ENABLE_3D
 
#undef DL_OP_EQUALS
 
      default:
        FML_DCHECK(false);
        return false;
    }
    switch (result) {
      case DisplayListCompare::kNotEqual:
        return false;
      case DisplayListCompare::kUseBulkCompare:
        break;
      case DisplayListCompare::kEqual:
        // Check if we have a backlog of bytes to bulk compare and then
        // reset the bulk compare pointers to the address following this op
        auto bulk_bytes = reinterpret_cast<const uint8_t*>(opA) - bulk_start_a;
        if (bulk_bytes > 0) {
          if (memcmp(bulk_start_a, bulk_start_b, bulk_bytes) != 0) {
            return false;
          }
        }
        bulk_start_a = ptrA;
        bulk_start_b = ptrB;
        break;
    }
  }
  if (ptrA != endA || ptrB != endB) {
    return false;
  }
  if (bulk_start_a < ptrA) {
    // Perform a final bulk compare if we have remaining bytes waiting
    if (memcmp(bulk_start_a, bulk_start_b, ptrA - bulk_start_a) != 0) {
      return false;
    }
  }
  return true;
}

compute_bounds()

static SkRect flutter::compute_bounds ( const SkPoint *  points, int  count  )

static

Definition at line 88 of file dl_vertices.cc.

                                                               {
  AccumulationRect accumulator;
  for (int i = 0; i < count; i++) {
    accumulator.accumulate(points[i]);
  }
  return accumulator.bounds();
}

ConfigureShell()

static void flutter::ConfigureShell ( Shell *  shell )

static

Definition at line 131 of file tester_main.cc.

                                         {
  auto device_pixel_ratio = 3.0;
  auto physical_width = 2400.0;   // 800 at 3x resolution.
  auto physical_height = 1800.0;  // 600 at 3x resolution.
 
  std::vector<std::unique_ptr<Display>> displays;
  displays.push_back(std::make_unique<Display>(
      0, 60, physical_width, physical_height, device_pixel_ratio));
  shell->OnDisplayUpdates(std::move(displays));
 
  flutter::ViewportMetrics metrics{};
  metrics.device_pixel_ratio = device_pixel_ratio;
  metrics.physical_width = physical_width;
  metrics.physical_height = physical_height;
  metrics.display_id = 0;
  shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId, metrics);
}

ConvertChar32ToUtf8()

std::string flutter::ConvertChar32ToUtf8

(

char32_t

ch

)

Definition at line 38 of file keyboard_key_embedder_handler.cc.

                                           {
  std::string result;
  FML_DCHECK(0 <= ch && ch <= 0x10FFFF) << "Character out of range";
  if (ch <= 0x007F) {
    result.push_back(ch);
  } else if (ch <= 0x07FF) {
    result.push_back(0b11000000 + _GetBit(ch, 11, 6));
    result.push_back(0b10000000 + _GetBit(ch, 6, 0));
  } else if (ch <= 0xFFFF) {
    result.push_back(0b11100000 + _GetBit(ch, 16, 12));
    result.push_back(0b10000000 + _GetBit(ch, 12, 6));
    result.push_back(0b10000000 + _GetBit(ch, 6, 0));
  } else {
    result.push_back(0b11110000 + _GetBit(ch, 21, 18));
    result.push_back(0b10000000 + _GetBit(ch, 18, 12));
    result.push_back(0b10000000 + _GetBit(ch, 12, 6));
    result.push_back(0b10000000 + _GetBit(ch, 6, 0));
  }
  return result;
}

ConvertImageToRasterSkia()

void flutter::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
	)

Definition at line 14 of file image_encoding_skia.cc.

                                                                           {
  // If the owning_context is kRaster, we can't access it on this task runner.
  if (dl_image->owning_context() != DlImage::OwningContext::kRaster) {
    auto image = dl_image->skia_image();
 
    // Check validity of the image.
    if (image == nullptr) {
      FML_LOG(ERROR) << "Image was null.";
      encode_task(nullptr);
      return;
    }
 
    auto dimensions = image->dimensions();
 
    if (dimensions.isEmpty()) {
      FML_LOG(ERROR) << "Image dimensions were empty.";
      encode_task(nullptr);
      return;
    }
 
    SkPixmap pixmap;
    if (image->peekPixels(&pixmap)) {
      // This is already a raster image.
      encode_task(image);
      return;
    }
 
    if (sk_sp<SkImage> raster_image = image->makeRasterImage()) {
      // The image can be converted to a raster image.
      encode_task(raster_image);
      return;
    }
  }
 
  if (!raster_task_runner) {
    FML_LOG(ERROR) << "Raster task runner was null.";
    encode_task(nullptr);
    return;
  }
 
  if (!io_task_runner) {
    FML_LOG(ERROR) << "IO task runner was null.";
    encode_task(nullptr);
    return;
  }
 
  // Cross-context images do not support makeRasterImage. Convert these images
  // by drawing them into a surface.  This must be done on the raster thread
  // to prevent concurrent usage of the image on both the IO and raster threads.
  raster_task_runner->PostTask([dl_image, encode_task = std::move(encode_task),
                                resource_context, snapshot_delegate,
                                io_task_runner, is_gpu_disabled_sync_switch,
                                raster_task_runner]() {
    auto image = dl_image->skia_image();
    if (!image || !snapshot_delegate) {
      io_task_runner->PostTask(
          [encode_task = encode_task]() mutable { encode_task(nullptr); });
      return;
    }
 
    sk_sp<SkImage> raster_image =
        snapshot_delegate->ConvertToRasterImage(image);
 
    io_task_runner->PostTask([image, encode_task = encode_task,
                              raster_image = std::move(raster_image),
                              resource_context, is_gpu_disabled_sync_switch,
                              owning_context = dl_image->owning_context(),
                              raster_task_runner]() mutable {
      if (!raster_image) {
        // The rasterizer was unable to render the cross-context image
        // (presumably because it does not have a GrContext).  In that case,
        // convert the image on the IO thread using the resource context.
        raster_image = ConvertToRasterUsingResourceContext(
            image, resource_context, is_gpu_disabled_sync_switch);
      }
      encode_task(raster_image);
      if (owning_context == DlImage::OwningContext::kRaster) {
        raster_task_runner->PostTask([image = std::move(image)]() {});
      }
    });
  });
}

ConvertMappingToNSData()

NSData * flutter::ConvertMappingToNSData

(

fml::MallocMapping

buffer

)

Definition at line 35 of file buffer_conversions.mm.

                                                        {
  size_t size = buffer.GetSize();
  return [NSData dataWithBytesNoCopy:buffer.Release() length:size];
}

ConvertMutation() [1/4]

static std::unique_ptr< FlutterPlatformViewMutation > flutter::ConvertMutation ( const SkMatrix &  matrix )

static

Definition at line 119 of file embedder_layers.cc.

                            {
  FlutterPlatformViewMutation mutation = {};
  mutation.type = kFlutterPlatformViewMutationTypeTransformation;
  mutation.transformation.scaleX = matrix[SkMatrix::kMScaleX];
  mutation.transformation.skewX = matrix[SkMatrix::kMSkewX];
  mutation.transformation.transX = matrix[SkMatrix::kMTransX];
  mutation.transformation.skewY = matrix[SkMatrix::kMSkewY];
  mutation.transformation.scaleY = matrix[SkMatrix::kMScaleY];
  mutation.transformation.transY = matrix[SkMatrix::kMTransY];
  mutation.transformation.pers0 = matrix[SkMatrix::kMPersp0];
  mutation.transformation.pers1 = matrix[SkMatrix::kMPersp1];
  mutation.transformation.pers2 = matrix[SkMatrix::kMPersp2];
  return std::make_unique<FlutterPlatformViewMutation>(mutation);
}

ConvertMutation() [2/4]

static std::unique_ptr< FlutterPlatformViewMutation > flutter::ConvertMutation ( const SkRect &  rect )

static

Definition at line 81 of file embedder_layers.cc.

                        {
  FlutterPlatformViewMutation mutation = {};
  mutation.type = kFlutterPlatformViewMutationTypeClipRect;
  mutation.clip_rect.left = rect.left();
  mutation.clip_rect.top = rect.top();
  mutation.clip_rect.right = rect.right();
  mutation.clip_rect.bottom = rect.bottom();
  return std::make_unique<FlutterPlatformViewMutation>(mutation);
}

ConvertMutation() [3/4]

static std::unique_ptr< FlutterPlatformViewMutation > flutter::ConvertMutation ( const SkRRect &  rrect )

static

Definition at line 99 of file embedder_layers.cc.

                          {
  FlutterPlatformViewMutation mutation = {};
  mutation.type = kFlutterPlatformViewMutationTypeClipRoundedRect;
  const auto& rect = rrect.rect();
  mutation.clip_rounded_rect.rect.left = rect.left();
  mutation.clip_rounded_rect.rect.top = rect.top();
  mutation.clip_rounded_rect.rect.right = rect.right();
  mutation.clip_rounded_rect.rect.bottom = rect.bottom();
  mutation.clip_rounded_rect.upper_left_corner_radius =
      VectorToSize(rrect.radii(SkRRect::Corner::kUpperLeft_Corner));
  mutation.clip_rounded_rect.upper_right_corner_radius =
      VectorToSize(rrect.radii(SkRRect::Corner::kUpperRight_Corner));
  mutation.clip_rounded_rect.lower_right_corner_radius =
      VectorToSize(rrect.radii(SkRRect::Corner::kLowerRight_Corner));
  mutation.clip_rounded_rect.lower_left_corner_radius =
      VectorToSize(rrect.radii(SkRRect::Corner::kLowerLeft_Corner));
  return std::make_unique<FlutterPlatformViewMutation>(mutation);
}

ConvertMutation() [4/4]

static std::unique_ptr< FlutterPlatformViewMutation > flutter::ConvertMutation ( double  opacity )

static

Definition at line 73 of file embedder_layers.cc.

                    {
  FlutterPlatformViewMutation mutation = {};
  mutation.type = kFlutterPlatformViewMutationTypeOpacity;
  mutation.opacity = opacity;
  return std::make_unique<FlutterPlatformViewMutation>(mutation);
}

ConvertNSDataToMappingPtr()

std::unique_ptr< fml::Mapping > flutter::ConvertNSDataToMappingPtr

(

NSData *

data

)

Definition at line 40 of file buffer_conversions.mm.

                                                                  {
  return std::make_unique<NSDataMapping>(data);
}

ConvertToFlutterLocale()

std::vector< FlutterLocale > flutter::ConvertToFlutterLocale

(

const std::vector< LanguageInfo > &

languages

)

Definition at line 131 of file system_utils.cc.

                                              {
  std::vector<FlutterLocale> flutter_locales;
  flutter_locales.reserve(languages.size());
  for (const auto& info : languages) {
    FlutterLocale locale = {};
    locale.struct_size = sizeof(FlutterLocale);
    locale.language_code = info.language.c_str();
    if (!info.territory.empty()) {
      locale.country_code = info.territory.c_str();
    }
    if (!info.codeset.empty()) {
      locale.script_code = info.codeset.c_str();
    }
    if (!info.modifier.empty()) {
      locale.variant_code = info.modifier.c_str();
    }
    flutter_locales.push_back(locale);
  }
 
  return flutter_locales;
}

ConvertToRasterUsingResourceContext()

template<typename SyncSwitch >

sk_sp< SkImage > flutter::ConvertToRasterUsingResourceContext	(	const sk_sp< SkImage > &	image,
		const fml::WeakPtr< GrDirectContext > &	resource_context,
		const std::shared_ptr< const SyncSwitch > &	is_gpu_disabled_sync_switch
	)

Definition at line 18 of file image_encoding_impl.h.

                                                                        {
  sk_sp<SkSurface> surface;
  SkImageInfo surface_info = SkImageInfo::MakeN32Premul(image->dimensions());
 
  is_gpu_disabled_sync_switch->Execute(
      typename SyncSwitch::Handlers()
          .SetIfTrue([&surface, &surface_info] {
            surface = SkSurfaces::Raster(surface_info);
          })
          .SetIfFalse([&surface, &surface_info, resource_context] {
            if (resource_context) {
              surface = SkSurfaces::RenderTarget(
                  resource_context.get(), skgpu::Budgeted::kNo, surface_info);
            } else {
              surface = SkSurfaces::Raster(surface_info);
            }
          }));
 
  if (surface == nullptr || surface->getCanvas() == nullptr) {
    FML_LOG(ERROR) << "Could not create a surface to copy the texture into.";
    return nullptr;
  }
 
  surface->getCanvas()->drawImage(image, 0, 0);
  if (resource_context) {
    resource_context->flushAndSubmit();
  }
 
  auto snapshot = surface->makeImageSnapshot();
 
  if (snapshot == nullptr) {
    FML_LOG(ERROR) << "Could not snapshot image to encode.";
    return nullptr;
  }
 
  return snapshot->makeRasterImage();
}

CopyMappingPtrToNSData()

NSData * flutter::CopyMappingPtrToNSData

(

std::unique_ptr< fml::Mapping >

mapping

)

Definition at line 44 of file buffer_conversions.mm.

                                                                  {
  return [NSData dataWithBytes:mapping->GetMapping() length:mapping->GetSize()];
}

CopyNSDataToMapping()

fml::MallocMapping flutter::CopyNSDataToMapping

(

NSData *

data

)

Definition at line 30 of file buffer_conversions.mm.

                                                   {
  const uint8_t* bytes = static_cast<const uint8_t*>(data.bytes);
  return fml::MallocMapping::Copy(bytes, data.length);
}

CopyV() [1/2]

static void flutter::CopyV ( void *  dst )

static

Definition at line 21 of file dl_builder.cc.

{}

CopyV() [2/2]

template<typename S , typename... Rest>

static void flutter::CopyV ( void *  dst, const S *  src, int  n, Rest &&...  rest  )

static

Definition at line 24 of file dl_builder.cc.

                                                                  {
  FML_DCHECK(((uintptr_t)dst & (alignof(S) - 1)) == 0)
      << "Expected " << dst << " to be aligned for at least " << alignof(S)
      << " bytes.";
  // If n is 0, there is nothing to copy into dst from src.
  if (n > 0) {
    memcpy(dst, src, n * sizeof(S));
    dst = reinterpret_cast<void*>(reinterpret_cast<uint8_t*>(dst) +
                                  n * sizeof(S));
  }
  // Repeat for the next items, if any
  CopyV(dst, std::forward<Rest>(rest)...);
}

CreateAndroidContext()

static std::shared_ptr< flutter::AndroidContext > flutter::CreateAndroidContext ( bool  use_software_rendering, const flutter::TaskRunners &  task_runners, AndroidRenderingAPI  android_rendering_api, bool  enable_vulkan_validation, bool  enable_opengl_gpu_tracing, bool  enable_vulkan_gpu_tracing  )

static

Definition at line 63 of file platform_view_android.cc.

                                    {
  switch (android_rendering_api) {
    case AndroidRenderingAPI::kSoftware:
      return std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
    case AndroidRenderingAPI::kImpellerOpenGLES:
      return std::make_unique<AndroidContextGLImpeller>(
          std::make_unique<impeller::egl::Display>(),
          enable_opengl_gpu_tracing);
    case AndroidRenderingAPI::kImpellerVulkan:
      return std::make_unique<AndroidContextVulkanImpeller>(
          enable_vulkan_validation, enable_vulkan_gpu_tracing);
    case AndroidRenderingAPI::kSkiaOpenGLES:
      return std::make_unique<AndroidContextGLSkia>(
          fml::MakeRefCounted<AndroidEnvironmentGL>(),  //
          task_runners                                  //
      );
  }
  FML_UNREACHABLE();
}

CreateContext()

static EGLResult< EGLContext > flutter::CreateContext ( EGLDisplay  display, EGLConfig  config, EGLContext  share = EGL_NO_CONTEXT  )

static

Definition at line 17 of file android_context_gl_skia.cc.

                                                                              {
  EGLint attributes[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
 
  EGLContext context = eglCreateContext(display, config, share, attributes);
 
  return {context != EGL_NO_CONTEXT, context};
}

CreateDeferredImage() [1/2]

static sk_sp< DlImage > flutter::CreateDeferredImage ( 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  )

static

Definition at line 58 of file picture.cc.

                                           {
#if IMPELLER_SUPPORTS_RENDERING
  if (impeller) {
    return DlDeferredImageGPUImpeller::Make(
        std::move(display_list), SkISize::Make(width, height),
        std::move(snapshot_delegate), std::move(raster_task_runner));
  }
#endif  // IMPELLER_SUPPORTS_RENDERING
 
#if SLIMPELLER
  FML_LOG(FATAL) << "Impeller opt-out unavailable.";
  return nullptr;
#else   // SLIMPELLER
  const SkImageInfo image_info = SkImageInfo::Make(
      width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
  return DlDeferredImageGPUSkia::Make(
      image_info, std::move(display_list), std::move(snapshot_delegate),
      raster_task_runner, std::move(unref_queue));
#endif  //  !SLIMPELLER
}

CreateDeferredImage() [2/2]

static sk_sp< DlImage > flutter::CreateDeferredImage ( 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  )

static

Definition at line 74 of file scene.cc.

                                           {
#if IMPELLER_SUPPORTS_RENDERING
  if (impeller) {
    return DlDeferredImageGPUImpeller::Make(std::move(layer_tree),
                                            std::move(snapshot_delegate),
                                            std::move(raster_task_runner));
  }
#endif  // IMPELLER_SUPPORTS_RENDERING
 
#if SLIMPELLER
  FML_LOG(FATAL) << "Impeller opt-out unavailable.";
  return nullptr;
#else   // SLIMPELLER
  const auto& frame_size = layer_tree->frame_size();
  const SkImageInfo image_info =
      SkImageInfo::Make(frame_size.width(), frame_size.height(),
                        kRGBA_8888_SkColorType, kPremul_SkAlphaType);
  return DlDeferredImageGPUSkia::MakeFromLayerTree(
      image_info, std::move(layer_tree), std::move(snapshot_delegate),
      raster_task_runner, std::move(unref_queue));
#endif  //  SLIMPELLER
}

CreateEmbedderTaskRunner()

static std::pair< bool, fml::RefPtr< EmbedderTaskRunner > > flutter::CreateEmbedderTaskRunner ( const FlutterTaskRunnerDescription *  description )

static

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.

Parameters

[in]

description

The description

Returns

A pair that returns if the embedder has specified a task runner (null otherwise) and whether to terminate further engine launch.

Definition at line 30 of file embedder_thread_host.cc.

                                                                          {
  if (description == nullptr) {
    // This is not embedder error. The embedder API will just have to create a
    // plain old task runner (and create a thread for it) instead of using a
    // task runner provided to us by the embedder.
    return {true, {}};
  }
 
  if (SAFE_ACCESS(description, runs_task_on_current_thread_callback, nullptr) ==
      nullptr) {
    FML_LOG(ERROR) << "FlutterTaskRunnerDescription.runs_task_on_current_"
                      "thread_callback was nullptr.";
    return {false, {}};
  }
 
  if (SAFE_ACCESS(description, post_task_callback, nullptr) == nullptr) {
    FML_LOG(ERROR)
        << "FlutterTaskRunnerDescription.post_task_callback was nullptr.";
    return {false, {}};
  }
 
  auto user_data = SAFE_ACCESS(description, user_data, nullptr);
 
  // ABI safety checks have been completed.
  auto post_task_callback_c = description->post_task_callback;
  auto runs_task_on_current_thread_callback_c =
      description->runs_task_on_current_thread_callback;
 
  EmbedderTaskRunner::DispatchTable task_runner_dispatch_table = {
      // .post_task_callback
      [post_task_callback_c, user_data](EmbedderTaskRunner* task_runner,
                                        uint64_t task_baton,
                                        fml::TimePoint target_time) -> void {
        FlutterTask task = {
            // runner
            reinterpret_cast<FlutterTaskRunner>(task_runner),
            // task
            task_baton,
        };
        post_task_callback_c(task, target_time.ToEpochDelta().ToNanoseconds(),
                             user_data);
      },
      // runs_task_on_current_thread_callback
      [runs_task_on_current_thread_callback_c, user_data]() -> bool {
        return runs_task_on_current_thread_callback_c(user_data);
      }};
 
  return {true, fml::MakeRefCounted<EmbedderTaskRunner>(
                    task_runner_dispatch_table,
                    SAFE_ACCESS(description, identifier, 0u))};
}

CreateFinishedBuildRecorder() [1/2]

static std::unique_ptr< FrameTimingsRecorder > flutter::CreateFinishedBuildRecorder ( )

static

Definition at line 147 of file rasterizer_unittests.cc.

                                                                         {
  return CreateFinishedBuildRecorder(fml::TimePoint::Now());
}

CreateFinishedBuildRecorder() [2/2]

static std::unique_ptr< FrameTimingsRecorder > flutter::CreateFinishedBuildRecorder ( fml::TimePoint  timestamp )

static

Definition at line 137 of file rasterizer_unittests.cc.

                            {
  std::unique_ptr<FrameTimingsRecorder> recorder =
      std::make_unique<FrameTimingsRecorder>();
  recorder->RecordVsync(timestamp, timestamp);
  recorder->RecordBuildStart(timestamp);
  recorder->RecordBuildEnd(timestamp);
  return recorder;
}

CreateFlutterCallbackInformation()

jobject flutter::CreateFlutterCallbackInformation	(	JNIEnv *	env,
		const std::string &	callbackName,
		const std::string &	callbackClassName,
		const std::string &	callbackLibraryPath
	)

Definition at line 69 of file platform_view_android_jni_impl.cc.

                                          {
  return env->NewObject(g_flutter_callback_info_class->obj(),
                        g_flutter_callback_info_constructor,
                        env->NewStringUTF(callbackName.c_str()),
                        env->NewStringUTF(callbackClassName.c_str()),
                        env->NewStringUTF(callbackLibraryPath.c_str()));
}

CreateFlutterViewID()

static std::string flutter::CreateFlutterViewID ( intptr_t  handler )

static

Definition at line 234 of file service_protocol.cc.

                                                       {
  std::stringstream stream;
  stream << kViewIdPrefx << "0x" << std::hex << handler;
  return stream.str();
}

CreateGLInterface()

static sk_sp< const GrGLInterface > flutter::CreateGLInterface ( const GPUSurfaceGLDelegate::GLProcResolver &  proc_resolver )

static

Definition at line 83 of file gpu_surface_gl_delegate.cc.

                                                             {
  if (proc_resolver == nullptr) {
#if defined(FML_OS_ANDROID)
    return GrGLInterfaces::MakeEGL();
#elif defined(FML_OS_LINUX)
#if defined(SK_GLX)
    return GrGLInterfaces::MakeGLX();
#else
    return nullptr;
#endif  // defined(SK_GLX)
#elif defined(FML_OS_IOS)
    return GrGLInterfaces::MakeIOS();
#elif defined(FML_OS_MACOSX)
    return GrGLInterfaces::MakeMac();
#else
    // TODO(kjlubick) update this when Skia has a Windows target for making GL
    // interfaces. For now, ask Skia to guess the native
    // interface. This often leads to interesting results on most platforms.
    return GrGLMakeNativeInterface();
#endif
  }
 
  struct ProcResolverContext {
    GPUSurfaceGLDelegate::GLProcResolver resolver;
  };
 
  ProcResolverContext context = {proc_resolver};
 
  GrGLGetProc gl_get_proc = [](void* context,
                               const char gl_proc_name[]) -> GrGLFuncPtr {
    auto proc_resolver_context =
        reinterpret_cast<ProcResolverContext*>(context);
    return reinterpret_cast<GrGLFuncPtr>(
        proc_resolver_context->resolver(gl_proc_name));
  };
 
  // glGetString indicates an OpenGL ES interface.
  if (IsProcResolverOpenGLES(proc_resolver)) {
    return GrGLMakeAssembledGLESInterface(&context, gl_get_proc);
  }
 
  // Fallback to OpenGL.
  if (auto interface = GrGLMakeAssembledGLInterface(&context, gl_get_proc)) {
    return interface;
  }
 
  FML_LOG(ERROR) << "Could not create a valid GL interface.";
  return nullptr;
}

CreateImpellerContext() [1/2]

static std::shared_ptr< impeller::Context > flutter::CreateImpellerContext ( const fml::RefPtr< fml::NativeLibrary > &  vulkan_dylib, bool  enable_vulkan_validation, bool  enable_gpu_tracing, bool  quiet  )

static

Definition at line 19 of file android_context_vulkan_impeller.cc.

                {
  if (!vulkan_dylib) {
    VALIDATION_LOG << "Could not open the Vulkan dylib.";
    return nullptr;
  }
 
  std::vector<std::shared_ptr<fml::Mapping>> shader_mappings = {
      std::make_shared<fml::NonOwnedMapping>(impeller_entity_shaders_vk_data,
                                             impeller_entity_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_framebuffer_blend_shaders_vk_data,
          impeller_framebuffer_blend_shaders_vk_length),
#if IMPELLER_ENABLE_3D
      std::make_shared<fml::NonOwnedMapping>(impeller_scene_shaders_vk_data,
                                             impeller_scene_shaders_vk_length),
#endif
      std::make_shared<fml::NonOwnedMapping>(impeller_modern_shaders_vk_data,
                                             impeller_modern_shaders_vk_length),
  };
 
  auto instance_proc_addr =
      vulkan_dylib->ResolveFunction<PFN_vkGetInstanceProcAddr>(
          "vkGetInstanceProcAddr");
 
  if (!instance_proc_addr.has_value()) {
    VALIDATION_LOG << "Could not setup Vulkan proc table.";
    return nullptr;
  }
 
  impeller::ContextVK::Settings settings;
  settings.proc_address_callback = instance_proc_addr.value();
  settings.shader_libraries_data = std::move(shader_mappings);
  settings.cache_directory = fml::paths::GetCachesDirectory();
  settings.enable_validation = enable_vulkan_validation;
  settings.enable_gpu_tracing = enable_gpu_tracing;
 
  auto context = impeller::ContextVK::Create(std::move(settings));
 
  if (!quiet) {
    if (context && impeller::CapabilitiesVK::Cast(*context->GetCapabilities())
                       .AreValidationsEnabled()) {
      FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (Vulkan with "
                            "Validation Layers).";
    } else {
      FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (Vulkan).";
    }
  }
 
  return context;
}

CreateImpellerContext() [2/2]

static std::shared_ptr< impeller::Context > flutter::CreateImpellerContext ( const std::shared_ptr< impeller::ReactorGLES::Worker > &  worker, bool  enable_gpu_tracing  )

static

Definition at line 52 of file android_context_gl_impeller.cc.

                             {
  auto proc_table = std::make_unique<impeller::ProcTableGLES>(
      impeller::egl::CreateProcAddressResolver());
 
  if (!proc_table->IsValid()) {
    FML_LOG(ERROR) << "Could not create OpenGL proc table.";
    return nullptr;
  }
 
  std::vector<std::shared_ptr<fml::Mapping>> shader_mappings = {
      std::make_shared<fml::NonOwnedMapping>(
          impeller_entity_shaders_gles_data,
          impeller_entity_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_framebuffer_blend_shaders_gles_data,
          impeller_framebuffer_blend_shaders_gles_length),
#if IMPELLER_ENABLE_3D
      std::make_shared<fml::NonOwnedMapping>(
          impeller_scene_shaders_gles_data, impeller_scene_shaders_gles_length),
#endif  // IMPELLER_ENABLE_3D
  };
 
  auto context = impeller::ContextGLES::Create(
      std::move(proc_table), shader_mappings, enable_gpu_tracing);
  if (!context) {
    FML_LOG(ERROR) << "Could not create OpenGLES Impeller Context.";
    return nullptr;
  }
 
  if (!context->AddReactorWorker(worker).has_value()) {
    FML_LOG(ERROR) << "Could not add reactor worker.";
    return nullptr;
  }
  FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (OpenGLES).";
  return context;
}

CreateImpellerRenderer()

static std::shared_ptr< impeller::Renderer > flutter::CreateImpellerRenderer ( std::shared_ptr< impeller::Context >  context )

static

Definition at line 24 of file gpu_surface_metal_impeller.mm.

                                            {
  auto renderer = std::make_shared<impeller::Renderer>(std::move(context));
  if (!renderer->IsValid()) {
    FML_LOG(ERROR) << "Could not create valid Impeller Renderer.";
    return nullptr;
  }
  return renderer;
}

CreateIsolateID()

static std::string flutter::CreateIsolateID ( int64_t  isolate )

static

Definition at line 240 of file service_protocol.cc.

                                                  {
  std::stringstream stream;
  stream << "isolates/" << isolate;
  return stream.str();
}

CreatePath()

API SkPath * flutter::CreatePath

(

SkPathFillType

fill_type

)

Definition at line 8 of file path_ops.cc.

                                             {
  auto* path = new SkPath();
  path->setFillType(fill_type);
  return path;
}

CreateSnapshotSurface()

static sk_sp< SkSurface > flutter::CreateSnapshotSurface ( GrDirectContext *  surface_context, const SkISize &  size  )

static

Definition at line 20 of file offscreen_surface.cc.

                                                                   {
  const auto image_info = SkImageInfo::MakeN32Premul(
      size.width(), size.height(), SkColorSpace::MakeSRGB());
  if (surface_context) {
    // There is a rendering surface that may contain textures that are going to
    // be referenced in the layer tree about to be drawn.
    return SkSurfaces::RenderTarget(surface_context, skgpu::Budgeted::kNo,
                                    image_info);
  }
 
  // There is no rendering surface, assume no GPU textures are present and
  // create a raster surface.
  return SkSurfaces::Raster(image_info);
}

CubicTo()

API void flutter::CubicTo	(	SkPath *	path,
		SkScalar	x1,
		SkScalar	y1,
		SkScalar	x2,
		SkScalar	y2,
		SkScalar	x3,
		SkScalar	y3
	)

Definition at line 26 of file path_ops.cc.

                          {
  path->cubicTo(x1, y1, x2, y2, x3, y3);
}

DartFileModifiedCallback()

bool flutter::DartFileModifiedCallback	(	const char *	source_url,
		int64_t	since_ms
	)

Definition at line 130 of file dart_vm.cc.

                                                                        {
  if (strncmp(source_url, kFileUriPrefix, kFileUriPrefixLength) != 0u) {
    // Assume modified.
    return true;
  }
 
  const char* path = source_url + kFileUriPrefixLength;
  struct stat info;
  if (stat(path, &info) < 0) {
    return true;
  }
 
  // If st_mtime is zero, it's more likely that the file system doesn't support
  // mtime than that the file was actually modified in the 1970s.
  if (!info.st_mtime) {
    return true;
  }
 
  // It's very unclear what time bases we're with here. The Dart API doesn't
  // document the time base for since_ms. Reading the code, the value varies by
  // platform, with a typical source being something like gettimeofday.
  //
  // We add one to st_mtime because st_mtime has less precision than since_ms
  // and we want to treat the file as modified if the since time is between
  // ticks of the mtime.
  fml::TimeDelta mtime = fml::TimeDelta::FromSeconds(info.st_mtime + 1);
  fml::TimeDelta since = fml::TimeDelta::FromMilliseconds(since_ms);
 
  return mtime > since;
}

DartFileRecorderArgs()

static std::string flutter::DartFileRecorderArgs ( const std::string &  path )

static

Definition at line 102 of file dart_vm.cc.

                                                             {
  std::ostringstream oss;
  oss << "--timeline_recorder=perfettofile:" << path;
  return oss.str();
}

DartOldGenHeapSizeArgs()

static std::string flutter::DartOldGenHeapSizeArgs ( uint64_t  heap_size )

static

Definition at line 121 of file dart_vm.cc.

                                                            {
  std::ostringstream oss;
  oss << "--old_gen_heap_size=" << heap_size;
  return oss.str();
}

DartPluginRegistrant_EnsureInitialized()

void flutter::DartPluginRegistrant_EnsureInitialized

(

)

Definition at line 269 of file dart_runtime_hooks.cc.

                                              {
  tonic::DartApiScope api_scope;
  FindAndInvokeDartPluginRegistrant();
}

DartTimelineTicksSinceEpoch()

fml::TimePoint flutter::DartTimelineTicksSinceEpoch

(

)

Definition at line 34 of file dart_timestamp_provider.cc.

                                           {
  return DartTimestampProvider::Instance().Now();
}

Data()

API struct PathData * flutter::Data

(

SkPath *

path

)

Definition at line 52 of file path_ops.cc.

                                    {
  int point_count = path->countPoints();
  int verb_count = path->countVerbs();
 
  auto data = new PathData();
  data->points = new float[point_count * 2];
  data->point_count = point_count * 2;
  data->verbs = new uint8_t[verb_count];
  data->verb_count = verb_count;
 
  path->getVerbs(data->verbs, verb_count);
  path->getPoints(reinterpret_cast<SkPoint*>(data->points), point_count);
  return data;
}

decodeFontFeatures()

void flutter::decodeFontFeatures	(	Dart_Handle	font_features_data,
		txt::FontFeatures &	font_features
	)

Definition at line 334 of file paragraph_builder.cc.

                                                        {  // NOLINT
  tonic::DartByteData byte_data(font_features_data);
  FML_CHECK(byte_data.length_in_bytes() % kBytesPerFontFeature == 0);
 
  size_t feature_count = byte_data.length_in_bytes() / kBytesPerFontFeature;
  for (size_t feature_index = 0; feature_index < feature_count;
       ++feature_index) {
    size_t feature_offset = feature_index * kBytesPerFontFeature;
    const char* feature_bytes =
        static_cast<const char*>(byte_data.data()) + feature_offset;
    std::string tag(feature_bytes, kFontFeatureTagLength);
    int32_t value = *(reinterpret_cast<const int32_t*>(feature_bytes +
                                                       kFontFeatureTagLength));
    font_features.SetFeature(tag, value);
  }
}

decodeFontVariations()

void flutter::decodeFontVariations	(	Dart_Handle	font_variations_data,
		txt::FontVariations &	font_variations
	)

Definition at line 352 of file paragraph_builder.cc.

                                                              {  // NOLINT
  tonic::DartByteData byte_data(font_variations_data);
  FML_CHECK(byte_data.length_in_bytes() % kBytesPerFontVariation == 0);
 
  size_t variation_count = byte_data.length_in_bytes() / kBytesPerFontVariation;
  for (size_t variation_index = 0; variation_index < variation_count;
       ++variation_index) {
    size_t variation_offset = variation_index * kBytesPerFontVariation;
    const char* variation_bytes =
        static_cast<const char*>(byte_data.data()) + variation_offset;
    std::string tag(variation_bytes, kFontVariationTagLength);
    float value = *(reinterpret_cast<const float*>(variation_bytes +
                                                   kFontVariationTagLength));
    font_variations.SetAxisValue(tag, value);
  }
}

decodeStrut()

void flutter::decodeStrut	(	Dart_Handle	strut_data,
		const std::vector< std::string > &	strut_font_families,
		txt::ParagraphStyle &	paragraph_style
	)

Definition at line 166 of file paragraph_builder.cc.

                                                     {  // NOLINT
  if (strut_data == Dart_Null()) {
    return;
  }
 
  tonic::DartByteData byte_data(strut_data);
  if (byte_data.length_in_bytes() == 0) {
    return;
  }
  paragraph_style.strut_enabled = true;
 
  const uint8_t* uint8_data = static_cast<const uint8_t*>(byte_data.data());
  uint8_t mask = uint8_data[0];
 
  // Data is stored in order of increasing size, eg, 8 bit ints will be before
  // any 32 bit ints. In addition, the order of decoding is the same order
  // as it is encoded, and the order is used to maintain consistency.
  size_t byte_count = 1;
  if (mask & kSFontWeightMask) {
    paragraph_style.strut_font_weight =
        static_cast<txt::FontWeight>(uint8_data[byte_count++]);
  }
  if (mask & kSFontStyleMask) {
    paragraph_style.strut_font_style =
        static_cast<txt::FontStyle>(uint8_data[byte_count++]);
  }
 
  paragraph_style.strut_half_leading = mask & kSLeadingDistributionMask;
 
  std::vector<float> float_data;
  float_data.resize((byte_data.length_in_bytes() - byte_count) / 4);
  memcpy(float_data.data(),
         static_cast<const char*>(byte_data.data()) + byte_count,
         byte_data.length_in_bytes() - byte_count);
  size_t float_count = 0;
  if (mask & kSFontSizeMask) {
    paragraph_style.strut_font_size = float_data[float_count++];
  }
  if (mask & kSHeightMask) {
    paragraph_style.strut_height = float_data[float_count++];
    paragraph_style.strut_has_height_override = true;
  }
  if (mask & kSLeadingMask) {
    paragraph_style.strut_leading = float_data[float_count++];
  }
 
  // The boolean is stored as the last bit in the bitmask, as null
  // and false have the same behavior.
  paragraph_style.force_strut_height = mask & kSForceStrutHeightMask;
 
  if (mask & kSFontFamilyMask) {
    paragraph_style.strut_font_families = strut_font_families;
  } else {
    // Provide an empty font name so that the platform default font will be
    // used.
    paragraph_style.strut_font_families.push_back("");
  }
}

decodeTextShadows()

void flutter::decodeTextShadows	(	Dart_Handle	shadows_data,
		std::vector< txt::TextShadow > &	decoded_shadows
	)

Definition at line 309 of file paragraph_builder.cc.

                                               {  // NOLINT
  decoded_shadows.clear();
 
  tonic::DartByteData byte_data(shadows_data);
  FML_CHECK(byte_data.length_in_bytes() % kBytesPerShadow == 0);
 
  const uint32_t* uint_data = static_cast<const uint32_t*>(byte_data.data());
  const float* float_data = static_cast<const float*>(byte_data.data());
 
  size_t shadow_count = byte_data.length_in_bytes() / kBytesPerShadow;
  size_t shadow_count_offset = 0;
  for (size_t shadow_index = 0; shadow_index < shadow_count; ++shadow_index) {
    shadow_count_offset = shadow_index * kShadowPropertiesCount;
    SkColor color =
        uint_data[shadow_count_offset + kColorOffset] ^ kColorDefault;
    decoded_shadows.emplace_back(
        color,
        SkPoint::Make(float_data[shadow_count_offset + kXOffset],
                      float_data[shadow_count_offset + kYOffset]),
        float_data[shadow_count_offset + kBlurOffset]);
  }
}

DEF_SWITCH() [1/27]

DEF_SWITCHES_START flutter::DEF_SWITCH	(	AotSharedLibraryName	,
		"aot-shared-library-name"	,
		"Name of the *.so containing AOT compiled Dart assets."
	)

DEF_SWITCH() [2/27]

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 flutter::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() [3/27]

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 flutter::DEF_SWITCH	(	DartFlags	,
		"dart-flags"	,
		"Flags passed directly to the Dart VM without being interpreted " "by the Flutter shell."
	)

DEF_SWITCH() [4/27]

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 flutter::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() [5/27]

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 flutter::DEF_SWITCH	(	DeviceObservatoryPort	,
		"observatory-port"	,
		"(deprecated) A custom Dart VM Service port. The default is to pick " "a randomly " "available open port."
	)

DEF_SWITCH() [6/27]

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 flutter::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() [7/27]

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 flutter::DEF_SWITCH	(	DisableObservatory	,
		"disable-observatory"	,
		"(deprecated) Disable the Dart VM Service. The Dart VM Service is " "never available " "in release mode."
	)

DEF_SWITCH() [8/27]

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 flutter::DEF_SWITCH	(	DisableObservatoryPublication	,
		"disable-observatory-publication"	,
		"(deprecated) Disable mDNS Dart VM Service publication."
	)

DEF_SWITCH() [9/27]

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 flutter::DEF_SWITCH	(	DisableServiceAuthCodes	,
		"disable-service-auth-codes"	,
		"Disable the requirement for authentication codes for communicating" " with the VM service."
	)

DEF_SWITCH() [10/27]

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 flutter::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() [11/27]

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 flutter::DEF_SWITCH	(	EnableDartProfiling	,
		"enable-dart-profiling"	,
		"Enable Dart profiling. Profiling information can be viewed from " "Dart / Flutter DevTools."
	)

DEF_SWITCH() [12/27]

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 flutter::DEF_SWITCH	(	EnableOpenGLGPUTracing	,
		"enable-opengl-gpu-tracing"	,
		"Enable tracing of GPU execution time when using the Impeller " "OpenGLES backend."
	)

DEF_SWITCH() [13/27]

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 flutter::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() [14/27]

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 flutter::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() [15/27]

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 flutter::DEF_SWITCH	(	ICUSymbolPrefix	,
		"icu-symbol-prefix"	,
		"Prefix for the symbols representing ICU data linked into the " "Flutter library."
	)

DEF_SWITCH() [16/27]

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 flutter::DEF_SWITCH	(	ImpellerBackend	,
		"impeller-backend"	,
		"Requests a particular Impeller backend on platforms that support " "multiple backends. (ex `opengles` or `vulkan`)"
	)

DEF_SWITCH() [17/27]

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 flutter::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() [18/27]

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 flutter::DEF_SWITCH	(	ResourceCacheMaxBytesThreshold	,
		"resource-cache-max-bytes-threshold"	,
		"The max bytes threshold of resource	cache,
		or 0 for unlimited."
	)

DEF_SWITCH() [19/27]

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::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() [20/27]

DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate flutter::DEF_SWITCH	(	SnapshotAssetPath	,
		"snapshot-asset-path"	,
		"Path to the directory containing the four files specified by " "	VmSnapshotData,
		VmSnapshotInstructions	,
		" "VmSnapshotInstructions and IsolateSnapshotInstructions."
	)

DEF_SWITCH() [21/27]

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 flutter::DEF_SWITCH	(	StartPaused	,
		"start-paused"	,
		"Start the application paused in the Dart debugger."
	)

DEF_SWITCH() [22/27]

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 flutter::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() [23/27]

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 flutter::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() [24/27]

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 flutter::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() [25/27]

it will be possible to load the file into Perfetto s trace viewer flutter::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() [26/27]

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 flutter::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() [27/27]

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 flutter::DEF_SWITCH	(	VmSnapshotInstructions	,
		"vm-snapshot-instr"	,
		"The VM instructions snapshot that will be memory mapped as read " "and executable. SnapshotAssetPath must be present."
	)

DefaultCameraTransform()

static impeller::Matrix flutter::DefaultCameraTransform ( )

static

Definition at line 62 of file scene_shader.cc.

                                               {
  // TODO(bdero): There's no way to know what the draw area will be yet, so
  //              make the DlSceneColorSource camera transform optional and
  //              defer this default (or parameterize the camera instead).
  return impeller::Matrix::MakePerspective(
             impeller::Degrees(45), impeller::ISize{800, 600}, 0.1f, 1000) *
         impeller::Matrix::MakeLookAt({0, 0, -5}, {0, 0, 0}, {0, 1, 0});
}

DeferredComponentInstallFailure()

static void flutter::DeferredComponentInstallFailure ( JNIEnv *  env, jobject  obj, jint  jLoadingUnitId, jstring  jError, jboolean  jTransient  )

static

Definition at line 594 of file platform_view_android_jni_impl.cc.

                                                                 {
  LoadLoadingUnitFailure(static_cast<intptr_t>(jLoadingUnitId),
                         fml::jni::JavaStringToString(env, jError),
                         static_cast<bool>(jTransient));
}

DEFINE_DRAW_POINTS_OP() [1/3]

flutter::DEFINE_DRAW_POINTS_OP	(	Lines	,
		kLines
	)

DEFINE_DRAW_POINTS_OP() [2/3]

flutter::DEFINE_DRAW_POINTS_OP	(	Points	,
		kPoints
	)

DEFINE_DRAW_POINTS_OP() [3/3]

flutter::DEFINE_DRAW_POINTS_OP	(	Polygon	,
		kPolygon
	)

DeserializeImageWithoutData()

sk_sp< SkImage > flutter::DeserializeImageWithoutData	(	const void *	data,
		size_t	length,
		void *	ctx
	)

Definition at line 56 of file serialization_callbacks.cc.

                                                      {
  FML_CHECK(length >= sizeof(ImageMetaData));
  auto metadata = static_cast<const ImageMetaData*>(data);
  sk_sp<SkColorSpace> color_space = nullptr;
  if (metadata->has_color_space) {
    color_space = SkColorSpace::Deserialize(
        static_cast<const uint8_t*>(data) + sizeof(ImageMetaData),
        length - sizeof(ImageMetaData));
  }
 
  auto image_size = SkISize::Make(metadata->width, metadata->height);
  auto info = SkImageInfo::Make(
      image_size, static_cast<SkColorType>(metadata->color_type),
      static_cast<SkAlphaType>(metadata->alpha_type), color_space);
  sk_sp<SkData> image_data =
      SkData::MakeUninitialized(image_size.width() * image_size.height() * 4);
  memset(image_data->writable_data(), 0x0f, image_data->size());
  sk_sp<SkImage> image =
      SkImages::RasterFromData(info, image_data, image_size.width() * 4);
 
  return image;
};

DeserializeTypefaceWithoutData()

sk_sp< SkTypeface > flutter::DeserializeTypefaceWithoutData	(	const void *	data,
		size_t	length,
		void *	ctx
	)

Definition at line 22 of file serialization_callbacks.cc.

                                                            {
  return nullptr;
}

DestroyData()

API void flutter::DestroyData

(

PathData *

data

)

Definition at line 67 of file path_ops.cc.

                                 {
  delete[] data->points;
  delete[] data->verbs;
  delete data;
}

DestroyJNI()

static void flutter::DestroyJNI ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder  )

static

Definition at line 171 of file platform_view_android_jni_impl.cc.

                                                                         {
  delete ANDROID_SHELL_HOLDER;
}

DestroyPath()

API void flutter::DestroyPath

(

SkPath *

path

)

Definition at line 14 of file path_ops.cc.

                               {
  delete path;
}

DestroyPathBuilder()

API void flutter::DestroyPathBuilder

(

SkPath *

path

)

DetermineRuntimeStageBackend()

static impeller::RuntimeStageBackend flutter::DetermineRuntimeStageBackend ( const std::shared_ptr< impeller::Context > &  impeller_context )

static

Definition at line 199 of file shell.cc.

                                                            {
  if (!impeller_context) {
    return impeller::RuntimeStageBackend::kSkSL;
  }
  switch (impeller_context->GetBackendType()) {
    case impeller::Context::BackendType::kMetal:
      return impeller::RuntimeStageBackend::kMetal;
    case impeller::Context::BackendType::kOpenGLES:
      return impeller::RuntimeStageBackend::kOpenGLES;
    case impeller::Context::BackendType::kVulkan:
      return impeller::RuntimeStageBackend::kVulkan;
  }
}

DispatchEmptyPlatformMessage()

static void flutter::DispatchEmptyPlatformMessage ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jstring  channel, jint  responseId  )

static

Definition at line 423 of file platform_view_android_jni_impl.cc.

                                                          {
  ANDROID_SHELL_HOLDER->GetPlatformView()->DispatchEmptyPlatformMessage(
      env,                                         //
      fml::jni::JavaStringToString(env, channel),  //
      responseId                                   //
  );
}

DispatchPlatformMessage()

static void flutter::DispatchPlatformMessage ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jstring  channel, jobject  message, jint  position, jint  responseId  )

static

Definition at line 407 of file platform_view_android_jni_impl.cc.

                                                     {
  ANDROID_SHELL_HOLDER->GetPlatformView()->DispatchPlatformMessage(
      env,                                         //
      fml::jni::JavaStringToString(env, channel),  //
      message,                                     //
      position,                                    //
      responseId                                   //
  );
}

DispatchPointerDataPacket()

static void flutter::DispatchPointerDataPacket ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jobject  buffer, jint  position  )

static

Definition at line 442 of file platform_view_android_jni_impl.cc.

                                                     {
  uint8_t* data = static_cast<uint8_t*>(env->GetDirectBufferAddress(buffer));
  auto packet = std::make_unique<flutter::PointerDataPacket>(data, position);
  ANDROID_SHELL_HOLDER->GetPlatformView()->DispatchPointerDataPacket(
      std::move(packet));
}

DispatchSemanticsAction()

static void flutter::DispatchSemanticsAction ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jint  id, jint  action, jobject  args, jint  args_position  )

static

Definition at line 453 of file platform_view_android_jni_impl.cc.

                                                        {
  ANDROID_SHELL_HOLDER->GetPlatformView()->DispatchSemanticsAction(
      env,           //
      id,            //
      action,        //
      args,          //
      args_position  //
  );
}

DisplayListBuilderBenchmarkAccessor()

DlOpReceiver & flutter::DisplayListBuilderBenchmarkAccessor

(

DisplayListBuilder &

builder

)

Definition at line 10 of file dl_builder_benchmarks.cc.

                                                                               {
  return builder.asReceiver();
}

DisplayListBuilderTestingAccessor()

DlOpReceiver & flutter::DisplayListBuilderTestingAccessor

(

DisplayListBuilder &

builder

)

Definition at line 33 of file display_list_unittests.cc.

                                                                             {
  return builder.asReceiver();
}

DisplayListBuilderTestingAttributes()

DlPaint flutter::DisplayListBuilderTestingAttributes

(

DisplayListBuilder &

builder

)

Definition at line 37 of file display_list_unittests.cc.

                                                                         {
  return builder.CurrentAttributes();
}

DisplayListBuilderTestingLastOpIndex()

int flutter::DisplayListBuilderTestingLastOpIndex

(

DisplayListBuilder &

builder

)

Definition at line 41 of file display_list_unittests.cc.

                                                                      {
  return builder.LastOpIndex();
}

DlGradientDeleter()

static void flutter::DlGradientDeleter ( void *  p )

static

Definition at line 13 of file dl_color_source.cc.

                                       {
  // Some of our target environments would prefer a sized delete,
  // but other target environments do not have that operator.
  // Use an unsized delete until we get better agreement in the
  // environments.
  // See https://github.com/flutter/flutter/issues/100327
  ::operator delete(p);
}

DlVerticesDeleter()

static void flutter::DlVerticesDeleter ( void *  p )

static

Definition at line 14 of file dl_vertices.cc.

                                       {
  // Some of our target environments would prefer a sized delete,
  // but other target environments do not have that operator.
  // Use an unsized delete until we get better agreement in the
  // environments.
  // See https://github.com/flutter/flutter/issues/100327
  ::operator delete(p);
}

DrawCheckerboard()

void flutter::DrawCheckerboard	(	DlCanvas *	canvas,
		const SkRect &	rect
	)

Definition at line 32 of file paint_utils.cc.

                                                            {
  // Draw a checkerboard
  canvas->Save();
  canvas->ClipRect(rect, DlCanvas::ClipOp::kIntersect, false);
 
  // Secure random number generation isn't needed here.
  // NOLINTBEGIN(clang-analyzer-security.insecureAPI.rand)
  auto checkerboard_color =
      SkColorSetARGB(64, rand() % 256, rand() % 256, rand() % 256);
  // NOLINTEND(clang-analyzer-security.insecureAPI.rand)
 
  DlPaint paint;
  paint.setColorSource(
      CreateCheckerboardShader(checkerboard_color, 0x00000000, 12));
  canvas->DrawPaint(paint);
  canvas->Restore();
 
  // Stroke the drawn area
  DlPaint debug_paint;
  debug_paint.setStrokeWidth(8);
  debug_paint.setColor(DlColor(SkColorSetA(checkerboard_color, 255)));
  debug_paint.setDrawStyle(DlDrawStyle::kStroke);
  canvas->DrawRect(rect, debug_paint);
}

elementSizeForFlutterStandardDataType()

UInt8 flutter::elementSizeForFlutterStandardDataType

(

FlutterStandardDataType

type

)

Definition at line 45 of file FlutterStandardCodec_Internal.h.

                                                                          {
  switch (type) {
    case FlutterStandardDataTypeUInt8:
      return 1;
    case FlutterStandardDataTypeInt32:
      return 4;
    case FlutterStandardDataTypeInt64:
      return 8;
    case FlutterStandardDataTypeFloat32:
      return 4;
    case FlutterStandardDataTypeFloat64:
      return 8;
  }
}

EmbedderInformationCallback()

static void flutter::EmbedderInformationCallback ( Dart_EmbedderInformation *  info )

static

Definition at line 253 of file dart_vm.cc.

                                                                        {
  info->version = DART_EMBEDDER_INFORMATION_CURRENT_VERSION;
  dart::bin::GetIOEmbedderInformation(info);
  info->name = "Flutter";
}

EnableTracingIfNecessary()

bool flutter::EnableTracingIfNecessary ( const Settings &  vm_settings )

inline

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.

This method may be called multiple times and will return the same result. There are no threading restrictions.

Parameters

[in]

vm_settings

The settings used to launch the VM.

Returns

If tracing was enabled.

Definition at line 45 of file ptrace_check.h.

                                                                  {
#if TRACING_CHECKS_NECESSARY
  return EnableTracingIfNecessaryImpl(vm_settings);
#else   // TRACING_CHECKS_NECESSARY
  return true;
#endif  // TRACING_CHECKS_NECESSARY
}

EncodeImage() [1/2]

Dart_Handle flutter::EncodeImage	(	CanvasImage *	canvas_image,
		int	format,
		Dart_Handle	callback_handle
	)

Definition at line 165 of file image_encoding.cc.

                                                     {
  if (!canvas_image) {
    return ToDart("encode called with non-genuine Image.");
  }
 
  if (!Dart_IsClosure(callback_handle)) {
    return ToDart("Callback must be a function.");
  }
 
  ImageByteFormat image_format = static_cast<ImageByteFormat>(format);
 
  auto callback = std::make_unique<DartPersistentValue>(
      tonic::DartState::Current(), callback_handle);
 
  const auto& task_runners = UIDartState::Current()->GetTaskRunners();
 
  // The static leak checker gets confused by the use of fml::MakeCopyable.
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
  task_runners.GetIOTaskRunner()->PostTask(fml::MakeCopyable(
      [callback = std::move(callback), image = canvas_image->image(),
       image_format, ui_task_runner = task_runners.GetUITaskRunner(),
       raster_task_runner = task_runners.GetRasterTaskRunner(),
       io_task_runner = task_runners.GetIOTaskRunner(),
       io_manager = UIDartState::Current()->GetIOManager(),
       snapshot_delegate = UIDartState::Current()->GetSnapshotDelegate(),
       is_impeller_enabled =
           UIDartState::Current()->IsImpellerEnabled()]() mutable {
        EncodeImageAndInvokeDataCallback(
            image, std::move(callback), image_format, ui_task_runner,
            raster_task_runner, io_task_runner,
            io_manager->GetResourceContext(), snapshot_delegate,
            io_manager->GetIsGpuDisabledSyncSwitch(),
            io_manager->GetImpellerContext(), is_impeller_enabled);
      }));
 
  return Dart_Null();
}

EncodeImage() [2/2]

fml::StatusOr< sk_sp< SkData > > flutter::EncodeImage	(	const sk_sp< SkImage > &	raster_image,
		ImageByteFormat	format
	)

Definition at line 205 of file image_encoding.cc.

                                                                 {
  TRACE_EVENT0("flutter", __FUNCTION__);
 
  if (!raster_image) {
    return fml::Status(fml::StatusCode::kInternal, "Missing raster image.");
  }
 
  switch (format) {
    case kPNG: {
      auto png_image = SkPngEncoder::Encode(nullptr, raster_image.get(), {});
 
      if (png_image == nullptr) {
        return fml::Status(fml::StatusCode::kInternal,
                           "Could not convert raster image to PNG.");
      };
      return png_image;
    }
    case kRawRGBA:
      return CopyImageByteData(raster_image, kRGBA_8888_SkColorType,
                               kPremul_SkAlphaType);
 
    case kRawStraightRGBA:
      return CopyImageByteData(raster_image, kRGBA_8888_SkColorType,
                               kUnpremul_SkAlphaType);
 
    case kRawUnmodified:
      return CopyImageByteData(raster_image, raster_image->colorType(),
                               raster_image->alphaType());
    case kRawExtendedRgba128:
      return CopyImageByteData(raster_image, kRGBA_F32_SkColorType,
                               kUnpremul_SkAlphaType);
  }
 
  return fml::Status(fml::StatusCode::kInternal,
                     "Unknown error encoding image.");
}

EncodeTextBoxes()

static tonic::Float32List flutter::EncodeTextBoxes ( const std::vector< txt::Paragraph::TextBox > &  boxes )

static

Definition at line 77 of file paragraph.cc.

                                                 {
  // Layout:
  // First value is the number of values.
  // Then there are boxes.size() groups of 5 which are LTRBD, where D is the
  // text direction index.
  tonic::Float32List result(
      Dart_NewTypedData(Dart_TypedData_kFloat32, boxes.size() * 5));
  uint64_t position = 0;
  for (uint64_t i = 0; i < boxes.size(); i++) {
    const txt::Paragraph::TextBox& box = boxes[i];
    result[position++] = box.rect.fLeft;
    result[position++] = box.rect.fTop;
    result[position++] = box.rect.fRight;
    result[position++] = box.rect.fBottom;
    result[position++] = static_cast<float>(box.direction);
  }
  return result;
}

EncodeUtf16()

std::u16string flutter::EncodeUtf16

(

char32_t

character

)

Definition at line 11 of file keyboard_utils.cc.

                                             {
  // Algorithm: https://en.wikipedia.org/wiki/UTF-16#Description
  std::u16string result;
  // Invalid value.
  FML_DCHECK(!(character >= 0xD800 && character <= 0xDFFF) &&
             !(character > 0x10FFFF));
  if ((character >= 0xD800 && character <= 0xDFFF) || (character > 0x10FFFF)) {
    return result;
  }
  if (character <= 0xD7FF || (character >= 0xE000 && character <= 0xFFFF)) {
    result.push_back((char16_t)character);
    return result;
  }
  uint32_t remnant = character - 0x10000;
  result.push_back((remnant >> 10) + 0xD800);
  result.push_back((remnant & 0x3FF) + 0xDC00);
  return result;
}

Equals() [1/4]

template<class T >

bool flutter::Equals	(	const T *	a,
		const T *	b
	)

Definition at line 19 of file dl_comparable.h.

                                    {
  if (a == b) {
    return true;
  }
  if (!a || !b) {
    return false;
  }
  return *a == *b;
}

Equals() [2/4]

template<class T >

bool flutter::Equals	(	const T *	a,
		std::shared_ptr< const T >	b
	)

Definition at line 40 of file dl_comparable.h.

                                                  {
  return Equals(a, b.get());
}

Equals() [3/4]

template<class T >

bool flutter::Equals	(	std::shared_ptr< const T >	a,
		const T *	b
	)

Definition at line 30 of file dl_comparable.h.

                                                  {
  return Equals(a.get(), b);
}

Equals() [4/4]

template<class T >

bool flutter::Equals	(	std::shared_ptr< const T >	a,
		std::shared_ptr< const T >	b
	)

Definition at line 50 of file dl_comparable.h.

                                                                {
  return Equals(a.get(), b.get());
}

FindAndInvokeDartPluginRegistrant()

bool flutter::FindAndInvokeDartPluginRegistrant

(

)

Returns

true when the registrant has been invoked.

Definition at line 42 of file dart_plugin_registrant.cc.

                                         {
  std::string library_name =
      dart_plugin_registrant_library_override == nullptr
          ? "package:flutter/src/dart_plugin_registrant.dart"
          : dart_plugin_registrant_library_override;
  Dart_Handle library = Dart_LookupLibrary(tonic::ToDart(library_name));
  if (Dart_IsError(library)) {
    return false;
  }
  Dart_Handle registrant_file_uri =
      Dart_GetField(library, tonic::ToDart("dartPluginRegistrantLibrary"));
  if (Dart_IsError(registrant_file_uri)) {
    // TODO(gaaclarke): Find a way to remove this branch so the field is
    // required. I couldn't get it working with unit tests.
    return InvokeDartPluginRegistrantIfAvailable(library);
  }
 
  std::string registrant_file_uri_string =
      tonic::DartConverter<std::string>::FromDart(registrant_file_uri);
  if (registrant_file_uri_string.empty()) {
    return false;
  }
 
  Dart_Handle registrant_library = Dart_LookupLibrary(registrant_file_uri);
  return InvokeDartPluginRegistrantIfAvailable(registrant_library);
}

FirstSupportedColorType()

static SkColorType flutter::FirstSupportedColorType ( GrDirectContext *  context, GrGLenum *  format  )

static

Definition at line 121 of file gpu_surface_gl_skia.cc.

                                                             {
#define RETURN_IF_RENDERABLE(x, y)                 \
  if (context->colorTypeSupportedAsSurface((x))) { \
    *format = (y);                                 \
    return (x);                                    \
  }
  RETURN_IF_RENDERABLE(kRGBA_8888_SkColorType, GPU_GL_RGBA8);
  RETURN_IF_RENDERABLE(kARGB_4444_SkColorType, GPU_GL_RGBA4);
  RETURN_IF_RENDERABLE(kRGB_565_SkColorType, GPU_GL_RGB565);
  return kUnknown_SkColorType;
}

FlagForSwitch()

const std::string_view flutter::FlagForSwitch

(

Switch

swtch

)

Definition at line 144 of file switches.cc.

                                                 {
  for (uint32_t i = 0; i < static_cast<uint32_t>(Switch::Sentinel); i++) {
    if (gSwitchDescs[i].sw == swtch) {
      return gSwitchDescs[i].flag;
    }
  }
  return std::string_view();
}

FlutterStandardDataTypeForField()

FlutterStandardDataType flutter::FlutterStandardDataTypeForField

(

FlutterStandardField

field

)

Definition at line 27 of file FlutterStandardCodec_Internal.h.

                                {
  switch (field) {
    case FlutterStandardFieldUInt8Data:
      return FlutterStandardDataTypeUInt8;
    case FlutterStandardFieldInt32Data:
      return FlutterStandardDataTypeInt32;
    case FlutterStandardFieldInt64Data:
      return FlutterStandardDataTypeInt64;
    case FlutterStandardFieldFloat32Data:
      return FlutterStandardDataTypeFloat32;
    case FlutterStandardFieldFloat64Data:
      return FlutterStandardDataTypeFloat64;
    default:
      return FlutterStandardDataTypeUInt8;
  }
}

FlutterStandardFieldForDataType()

FlutterStandardField flutter::FlutterStandardFieldForDataType

(

FlutterStandardDataType

type

)

Definition at line 12 of file FlutterStandardCodec_Internal.h.

                                  {
  switch (type) {
    case FlutterStandardDataTypeUInt8:
      return FlutterStandardFieldUInt8Data;
    case FlutterStandardDataTypeInt32:
      return FlutterStandardFieldInt32Data;
    case FlutterStandardDataTypeInt64:
      return FlutterStandardFieldInt64Data;
    case FlutterStandardDataTypeFloat32:
      return FlutterStandardFieldFloat32Data;
    case FlutterStandardDataTypeFloat64:
      return FlutterStandardFieldFloat64Data;
  }
}

FlutterTextUtilsIsEmoji()

static jboolean flutter::FlutterTextUtilsIsEmoji ( JNIEnv *  env, jobject  obj, jint  codePoint  )

static

Definition at line 558 of file platform_view_android_jni_impl.cc.

                                                        {
  return u_hasBinaryProperty(codePoint, UProperty::UCHAR_EMOJI);
}

FlutterTextUtilsIsEmojiModifier()

static jboolean flutter::FlutterTextUtilsIsEmojiModifier ( JNIEnv *  env, jobject  obj, jint  codePoint  )

static

Definition at line 564 of file platform_view_android_jni_impl.cc.

                                                                {
  return u_hasBinaryProperty(codePoint, UProperty::UCHAR_EMOJI_MODIFIER);
}

FlutterTextUtilsIsEmojiModifierBase()

static jboolean flutter::FlutterTextUtilsIsEmojiModifierBase ( JNIEnv *  env, jobject  obj, jint  codePoint  )

static

Definition at line 570 of file platform_view_android_jni_impl.cc.

                                                                    {
  return u_hasBinaryProperty(codePoint, UProperty::UCHAR_EMOJI_MODIFIER_BASE);
}

FlutterTextUtilsIsRegionalIndicator()

static jboolean flutter::FlutterTextUtilsIsRegionalIndicator ( JNIEnv *  env, jobject  obj, jint  codePoint  )

static

Definition at line 582 of file platform_view_android_jni_impl.cc.

                                                                    {
  return u_hasBinaryProperty(codePoint, UProperty::UCHAR_REGIONAL_INDICATOR);
}

FlutterTextUtilsIsVariationSelector()

static jboolean flutter::FlutterTextUtilsIsVariationSelector ( JNIEnv *  env, jobject  obj, jint  codePoint  )

static

Definition at line 576 of file platform_view_android_jni_impl.cc.

                                                                    {
  return u_hasBinaryProperty(codePoint, UProperty::UCHAR_VARIATION_SELECTOR);
}

ForceShutdownIsolate()

EXPORTED void flutter::ForceShutdownIsolate

(

)

Definition at line 604 of file tester_main.cc.

                                     {
  // Enable Isolate.exit().
  FML_DCHECK(Dart_CurrentIsolate() != nullptr);
  Dart_Handle isolate_lib = Dart_LookupLibrary(tonic::ToDart("dart:isolate"));
  FML_CHECK(!tonic::CheckAndHandleError(isolate_lib));
  Dart_Handle isolate_type = Dart_GetNonNullableType(
      isolate_lib, tonic::ToDart("Isolate"), 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(isolate_type));
  Dart_Handle result =
      Dart_SetField(isolate_type, tonic::ToDart("_mayExit"), Dart_True());
  FML_CHECK(!tonic::CheckAndHandleError(result));
}

GetBitmap()

static jobject flutter::GetBitmap ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder  )

static

Definition at line 373 of file platform_view_android_jni_impl.cc.

                                                                           {
  auto screenshot = ANDROID_SHELL_HOLDER->Screenshot(
      Rasterizer::ScreenshotType::UncompressedImage, false);
  if (screenshot.data == nullptr) {
    return nullptr;
  }
 
  jstring argb = env->NewStringUTF("ARGB_8888");
  if (argb == nullptr) {
    return nullptr;
  }
 
  jobject bitmap_config = env->CallStaticObjectMethod(
      g_bitmap_config_class->obj(), g_bitmap_config_value_of, argb);
  if (bitmap_config == nullptr) {
    return nullptr;
  }
 
  auto bitmap = env->CallStaticObjectMethod(
      g_bitmap_class->obj(), g_bitmap_create_bitmap_method,
      screenshot.frame_size.width(), screenshot.frame_size.height(),
      bitmap_config);
 
  fml::jni::ScopedJavaLocalRef<jobject> buffer(
      env,
      env->NewDirectByteBuffer(const_cast<uint8_t*>(screenshot.data->bytes()),
                               screenshot.data->size()));
 
  env->CallVoidMethod(bitmap, g_bitmap_copy_pixels_from_buffer_method,
                      buffer.obj());
 
  return bitmap;
}

GetCATransform3DFromSkMatrix()

CATransform3D flutter::GetCATransform3DFromSkMatrix

(

const SkMatrix &

matrix

)

Definition at line 43 of file FlutterPlatformViews_Internal.mm.

                                                                   {
  // Skia only supports 2D transform so we don't map z.
  CATransform3D transform = CATransform3DIdentity;
  transform.m11 = matrix.getScaleX();
  transform.m21 = matrix.getSkewX();
  transform.m41 = matrix.getTranslateX();
  transform.m14 = matrix.getPerspX();
 
  transform.m12 = matrix.getSkewY();
  transform.m22 = matrix.getScaleY();
  transform.m42 = matrix.getTranslateY();
  transform.m24 = matrix.getPerspY();
  return transform;
}

GetCGRectFromSkRect()

CGRect flutter::GetCGRectFromSkRect

(

const SkRect &

clipSkRect

)

Definition at line 64 of file FlutterPlatformViews_Internal.mm.

                                                     {
  return CGRectMake(clipSkRect.fLeft, clipSkRect.fTop, clipSkRect.fRight - clipSkRect.fLeft,
                    clipSkRect.fBottom - clipSkRect.fTop);
}

GetColorSpace()

SkColorSpace * flutter::GetColorSpace ( DlCanvas *  canvas )

inline

Definition at line 25 of file layer_tree.cc.

                                                     {
  return canvas ? canvas->GetImageInfo().colorSpace() : nullptr;
}

GetCoreAnimationLayerClassForRenderingAPI()

Class flutter::GetCoreAnimationLayerClassForRenderingAPI

(

IOSRenderingAPI

rendering_api

)

Definition at line 59 of file rendering_api_selection.mm.

                                                                               {
  switch (rendering_api) {
    case IOSRenderingAPI::kSoftware:
      return [CALayer class];
    case IOSRenderingAPI::kMetal:
      if (@available(iOS METAL_IOS_VERSION_BASELINE, *)) {
        if ([FlutterMetalLayer enabled]) {
          return [FlutterMetalLayer class];
        } else {
          return [CAMetalLayer class];
        }
      }
      FML_CHECK(false) << "Metal availability should already have been checked";
      break;
    default:
      break;
  }
  FML_CHECK(false) << "Unknown client rendering API";
  return [CALayer class];
}

GetCurrentThreadTaskRunner()

static fml::RefPtr< fml::TaskRunner > flutter::GetCurrentThreadTaskRunner ( )

static

Definition at line 108 of file embedder_thread_host.cc.

                                                             {
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  return fml::MessageLoop::GetCurrent().GetTaskRunner();
}

GetCursorFromBuffer()

HCURSOR flutter::GetCursorFromBuffer	(	const std::vector< uint8_t > &	buffer,
		double	hot_x,
		double	hot_y,
		int	width,
		int	height
	)

Definition at line 205 of file cursor_handler.cc.

                                        {
  HCURSOR cursor = nullptr;
  HDC display_dc = GetDC(NULL);
  // Flutter should returns rawBGRA, which has 8bits * 4channels.
  BITMAPINFO bmi;
  memset(&bmi, 0, sizeof(bmi));
  bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth = width;
  bmi.bmiHeader.biHeight = -height;
  bmi.bmiHeader.biPlanes = 1;
  bmi.bmiHeader.biBitCount = 32;
  bmi.bmiHeader.biCompression = BI_RGB;
  bmi.bmiHeader.biSizeImage = width * height * 4;
  // Create the pixmap DIB section
  uint8_t* pixels = 0;
  HBITMAP bitmap =
      CreateDIBSection(display_dc, &bmi, DIB_RGB_COLORS, (void**)&pixels, 0, 0);
  ReleaseDC(0, display_dc);
  if (!bitmap || !pixels) {
    return nullptr;
  }
  int bytes_per_line = width * 4;
  for (int y = 0; y < height; ++y) {
    memcpy(pixels + y * bytes_per_line, &buffer[bytes_per_line * y],
           bytes_per_line);
  }
  HBITMAP mask;
  GetMaskBitmaps(bitmap, mask);
  ICONINFO icon_info;
  icon_info.fIcon = 0;
  icon_info.xHotspot = hot_x;
  icon_info.yHotspot = hot_y;
  icon_info.hbmMask = mask;
  icon_info.hbmColor = bitmap;
  cursor = CreateIconIndirect(&icon_info);
  DeleteObject(mask);
  DeleteObject(bitmap);
  return cursor;
}

GetDartVersion()

const char * flutter::GetDartVersion

(

)

Definition at line 19 of file version.cc.

                             {
  return DART_VERSION;
}

GetDefaultPlatformData()

static PlatformData flutter::GetDefaultPlatformData ( )

static

Definition at line 79 of file android_shell_holder.cc.

                                             {
  PlatformData platform_data;
  platform_data.lifecycle_state = "AppLifecycleState.detached";
  return platform_data;
}

GetDpiForHWND()

UINT flutter::GetDpiForHWND

(

HWND

hwnd

)

Returns the DPI for |hwnd|. Supports all DPI awareness modes, and is backward compatible down to Windows Vista. If |hwnd| is nullptr, returns the DPI for the primary monitor. If Per-Monitor DPI awareness is not available, returns the system's DPI.

Definition at line 130 of file dpi_utils.cc.

                              {
  return GetHelper()->GetDpiForWindow(hwnd);
}

GetDpiForMonitor()

UINT flutter::GetDpiForMonitor

(

HMONITOR

monitor

)

Returns the DPI of a given monitor. Defaults to 96 if the API is not available.

Definition at line 134 of file dpi_utils.cc.

                                        {
  return GetHelper()->GetDpiForMonitor(monitor);
}

GetExecutableDirectory()

std::filesystem::path flutter::GetExecutableDirectory

(

)

Definition at line 16 of file path_utils.cc.

                                           {
#if defined(_WIN32)
  wchar_t buffer[MAX_PATH];
  if (GetModuleFileName(nullptr, buffer, MAX_PATH) == 0) {
    return std::filesystem::path();
  }
  std::filesystem::path executable_path(buffer);
  return executable_path.remove_filename();
#elif defined(__linux__)
  char buffer[PATH_MAX + 1];
  ssize_t length = readlink("/proc/self/exe", buffer, sizeof(buffer));
  if (length > PATH_MAX) {
    return std::filesystem::path();
  }
  std::filesystem::path executable_path(std::string(buffer, length));
  return executable_path.remove_filename();
#else
  return std::filesystem::path();
#endif
}

GetFileMapping()

static std::unique_ptr< const fml::Mapping > flutter::GetFileMapping ( const std::string &  path, bool  executable  )

static

Definition at line 32 of file dart_snapshot.cc.

                     {
  if (executable) {
    return fml::FileMapping::CreateReadExecute(path);
  } else {
    return fml::FileMapping::CreateReadOnly(path);
  }
}

GetFillType()

API int flutter::GetFillType

(

SkPath *

path

)

Definition at line 48 of file path_ops.cc.

                              {
  return static_cast<int>(path->getFillType());
}

GetFlutterEngineVersion()

const char * flutter::GetFlutterEngineVersion

(

)

Definition at line 11 of file version.cc.

                                      {
  return FLUTTER_ENGINE_VERSION;
}

GetFontFile()

const std::string & flutter::GetFontFile

(

)

Definition at line 20 of file flow_test_utils.cc.

                               {
  return gFontFile;
}

GetFunctionClassName()

static std::string flutter::GetFunctionClassName ( Dart_Handle  closure )

static

Definition at line 196 of file dart_runtime_hooks.cc.

                                                           {
  Dart_Handle result;
 
  if (Dart_IsClosure(closure)) {
    closure = Dart_ClosureFunction(closure);
    PropagateIfError(closure);
  }
 
  if (!Dart_IsFunction(closure)) {
    return "";
  }
 
  bool is_static = false;
  result = Dart_FunctionIsStatic(closure, &is_static);
  PropagateIfError(result);
  if (!is_static) {
    return "";
  }
 
  result = Dart_FunctionOwner(closure);
  PropagateIfError(result);
 
  if (Dart_IsLibrary(result) || !Dart_IsInstance(result)) {
    return "";
  }
  return DartConverter<std::string>::FromDart(Dart_ClassName(result));
}

GetFunctionLibraryUrl()

static std::string flutter::GetFunctionLibraryUrl ( Dart_Handle  closure )

static

Definition at line 174 of file dart_runtime_hooks.cc.

                                                            {
  if (Dart_IsClosure(closure)) {
    closure = Dart_ClosureFunction(closure);
    PropagateIfError(closure);
  }
 
  if (!Dart_IsFunction(closure)) {
    return "";
  }
 
  Dart_Handle url = Dart_Null();
  Dart_Handle owner = Dart_FunctionOwner(closure);
  if (Dart_IsInstance(owner)) {
    owner = Dart_ClassLibrary(owner);
  }
  if (Dart_IsLibrary(owner)) {
    url = Dart_LibraryUrl(owner);
    PropagateIfError(url);
  }
  return DartConverter<std::string>::FromDart(url);
}

GetFunctionName()

static std::string flutter::GetFunctionName ( Dart_Handle  func )

static

Definition at line 224 of file dart_runtime_hooks.cc.

                                                   {
  if (Dart_IsClosure(func)) {
    func = Dart_ClosureFunction(func);
    PropagateIfError(func);
  }
 
  if (!Dart_IsFunction(func)) {
    return "";
  }
 
  bool is_static = false;
  Dart_Handle result = Dart_FunctionIsStatic(func, &is_static);
  PropagateIfError(result);
  if (!is_static) {
    return "";
  }
 
  result = Dart_FunctionName(func);
  PropagateIfError(result);
 
  return DartConverter<std::string>::FromDart(result);
}

GetGoldenDir()

const std::string & flutter::GetGoldenDir

(

)

Definition at line 12 of file flow_test_utils.cc.

                                {
  return gGoldenDir;
}

getInfoIncludingExif()

static SkImageInfo flutter::getInfoIncludingExif ( SkCodec *  codec )

static

Definition at line 86 of file image_generator.cc.

                                                        {
  SkImageInfo info = codec->getInfo();
  if (SkEncodedOriginSwapsWidthHeight(codec->getOrigin())) {
    info = SkPixmapUtils::SwapWidthHeight(info);
  }
  if (kUnpremul_SkAlphaType == info.alphaType()) {
    // Prefer premul over unpremul (this produces better filtering in general)
    info = info.makeAlphaType(kPremul_SkAlphaType);
  }
  return info;
}

GetIsSoftwareRendering()

static jboolean flutter::GetIsSoftwareRendering ( JNIEnv *  env, jobject  jcaller  )

static

Definition at line 483 of file platform_view_android_jni_impl.cc.

                                                                     {
  return FlutterMain::Get().GetSettings().enable_software_rendering;
}

GetMaskBitmaps()

void flutter::GetMaskBitmaps	(	HBITMAP	bitmap,
		HBITMAP &	mask_bitmap
	)

Definition at line 249 of file cursor_handler.cc.

                                                          {
  HDC h_dc = ::GetDC(NULL);
  HDC h_main_dc = ::CreateCompatibleDC(h_dc);
  HDC h_and_mask_dc = ::CreateCompatibleDC(h_dc);
 
  // Get the dimensions of the source bitmap
  BITMAP bm;
  ::GetObject(bitmap, sizeof(BITMAP), &bm);
  mask_bitmap = ::CreateCompatibleBitmap(h_dc, bm.bmWidth, bm.bmHeight);
 
  // Select the bitmaps to DC
  HBITMAP h_old_main_bitmap = (HBITMAP)::SelectObject(h_main_dc, bitmap);
  HBITMAP h_old_and_mask_bitmap =
      (HBITMAP)::SelectObject(h_and_mask_dc, mask_bitmap);
 
  // Scan each pixel of the souce bitmap and create the masks
  COLORREF main_bit_pixel;
  for (int x = 0; x < bm.bmWidth; ++x) {
    for (int y = 0; y < bm.bmHeight; ++y) {
      main_bit_pixel = ::GetPixel(h_main_dc, x, y);
      if (main_bit_pixel == RGB(0, 0, 0)) {
        ::SetPixel(h_and_mask_dc, x, y, RGB(255, 255, 255));
      } else {
        ::SetPixel(h_and_mask_dc, x, y, RGB(0, 0, 0));
      }
    }
  }
  ::SelectObject(h_main_dc, h_old_main_bitmap);
  ::SelectObject(h_and_mask_dc, h_old_and_mask_bitmap);
 
  ::DeleteDC(h_and_mask_dc);
  ::DeleteDC(h_main_dc);
 
  ::ReleaseDC(NULL, h_dc);
}

GetNextPipelineTraceID()

size_t flutter::GetNextPipelineTraceID

(

)

Definition at line 9 of file pipeline.cc.

                                {
  static std::atomic_size_t PipelineLastTraceID = {0};
  return ++PipelineLastTraceID;
}

GetPreferredLanguageInfo() [1/2]

std::vector< LanguageInfo > flutter::GetPreferredLanguageInfo

(

)

Definition at line 114 of file system_utils.cc.

                                                   {
  const char* locale_string;
  locale_string = GetLocaleStringFromEnvironment();
  if (!locale_string || locale_string[0] == '\0') {
    // This is the default locale if none is specified according to ISO C.
    locale_string = "C";
  }
  std::istringstream locales_stream(locale_string);
  std::vector<LanguageInfo> languages;
  std::string s;
  while (getline(locales_stream, s, ':')) {
    LanguageInfo info = ParseLocale(s);
    AppendLocaleVariants(languages, info);
  }
  return languages;
}

GetPreferredLanguageInfo() [2/2]

std::vector< LanguageInfo > flutter::GetPreferredLanguageInfo

(

const WindowsProcTable &

windows_proc_table

)

Definition at line 15 of file system_utils.cc.

                                                {
  std::vector<std::wstring> languages =
      GetPreferredLanguages(windows_proc_table);
  std::vector<LanguageInfo> language_info;
  language_info.reserve(languages.size());
 
  for (auto language : languages) {
    language_info.push_back(ParseLanguageName(language));
  }
  return language_info;
}

GetPreferredLanguages()

std::vector< std::wstring > flutter::GetPreferredLanguages

(

const WindowsProcTable &

windows_proc_table

)

Definition at line 45 of file system_utils.cc.

                                                {
  std::vector<std::wstring> languages;
 
  // Initialize the buffer
  std::wstring buffer = GetPreferredLanguagesFromMUI(windows_proc_table);
 
  // Extract the individual languages from the buffer.
  size_t start = 0;
  while (true) {
    // The buffer is terminated by an empty string (i.e., a double null).
    if (buffer[start] == L'\0') {
      break;
    }
    // Read the next null-terminated language.
    std::wstring language(buffer.c_str() + start);
    if (language.empty()) {
      break;
    }
    languages.push_back(language);
    // Skip past that language and its terminating null in the buffer.
    start += language.size() + 1;
  }
  return languages;
}

GetPreferredLanguagesFromMUI()

std::wstring flutter::GetPreferredLanguagesFromMUI

(

const WindowsProcTable &

windows_proc_table

)

Definition at line 28 of file system_utils.cc.

                                                {
  ULONG buffer_size = 0;
  ULONG count = 0;
  DWORD flags = MUI_LANGUAGE_NAME | MUI_UI_FALLBACK;
  if (!windows_proc_table.GetThreadPreferredUILanguages(flags, &count, nullptr,
                                                        &buffer_size)) {
    return std::wstring();
  }
  std::wstring buffer(buffer_size, '\0');
  if (!windows_proc_table.GetThreadPreferredUILanguages(
          flags, &count, buffer.data(), &buffer_size)) {
    return std::wstring();
  }
  return buffer;
}

GetRasterData()

static sk_sp< SkData > flutter::GetRasterData ( const sk_sp< SkSurface > &  offscreen_surface, bool  compressed  )

static

Returns a buffer containing a snapshot of the surface.

If compressed is true the data is encoded as PNG.

Definition at line 39 of file offscreen_surface.cc.

                                                    {
  // Prepare an image from the surface, this image may potentially be on th GPU.
  auto potentially_gpu_snapshot = offscreen_surface->makeImageSnapshot();
  if (!potentially_gpu_snapshot) {
    FML_LOG(ERROR) << "Screenshot: unable to make image screenshot";
    return nullptr;
  }
 
  // Copy the GPU image snapshot into CPU memory.
  // TODO (https://github.com/flutter/flutter/issues/13498)
  auto cpu_snapshot = potentially_gpu_snapshot->makeRasterImage();
  if (!cpu_snapshot) {
    FML_LOG(ERROR) << "Screenshot: unable to make raster image";
    return nullptr;
  }
 
  // If the caller want the pixels to be compressed, there is a Skia utility to
  // compress to PNG. Use that.
  if (compressed) {
    return SkPngEncoder::Encode(nullptr, cpu_snapshot.get(), {});
  }
 
  // Copy it into a bitmap and return the same.
  SkPixmap pixmap;
  if (!cpu_snapshot->peekPixels(&pixmap)) {
    FML_LOG(ERROR) << "Screenshot: unable to obtain bitmap pixels";
    return nullptr;
  }
  return SkData::MakeWithCopy(pixmap.addr32(), pixmap.computeByteSize());
}

GetRenderingAPIForProcess()

IOSRenderingAPI flutter::GetRenderingAPIForProcess

(

bool

force_software

)

Definition at line 31 of file rendering_api_selection.mm.

                                                               {
#if TARGET_OS_SIMULATOR
  if (force_software) {
    return IOSRenderingAPI::kSoftware;
  }
#else
  if (force_software) {
    FML_LOG(WARNING) << "The --enable-software-rendering is only supported on Simulator targets "
                        "and will be ignored.";
  }
#endif  // TARGET_OS_SIMULATOR
 
  static bool should_use_metal = ShouldUseMetalRenderer();
  if (should_use_metal) {
    return IOSRenderingAPI::kMetal;
  }
 
  // When Metal isn't available we use Skia software rendering since it performs
  // a little better than emulated OpenGL. Also, omitting an OpenGL backend
  // reduces binary footprint.
#if TARGET_OS_SIMULATOR
  return IOSRenderingAPI::kSoftware;
#else
  FML_CHECK(false) << "Metal may only be unavailable on simulators";
  return IOSRenderingAPI::kSoftware;
#endif  // TARGET_OS_SIMULATOR
}

GetSkiaVersion()

const char * flutter::GetSkiaVersion

(

)

Definition at line 15 of file version.cc.

                             {
  return SKIA_VERSION;
}

GetSwitchesFromEnvironment()

std::vector< std::string > flutter::GetSwitchesFromEnvironment

(

)

Definition at line 14 of file engine_switches.cc.

                                                  {
  std::vector<std::string> switches;
  // Read engine switches from the environment in debug/profile. If release mode
  // support is needed in the future, it should likely use a whitelist.
#ifndef FLUTTER_RELEASE
  const char* switch_count_key = "FLUTTER_ENGINE_SWITCHES";
  const int kMaxSwitchCount = 50;
  const char* switch_count_string = std::getenv(switch_count_key);
  if (!switch_count_string) {
    return switches;
  }
  int switch_count = std::min(kMaxSwitchCount, atoi(switch_count_string));
  for (int i = 1; i <= switch_count; ++i) {
    std::ostringstream switch_key;
    switch_key << "FLUTTER_ENGINE_SWITCH_" << i;
    const char* switch_value = std::getenv(switch_key.str().c_str());
    if (switch_value) {
      std::ostringstream switch_value_as_flag;
      switch_value_as_flag << "--" << switch_value;
      switches.push_back(switch_value_as_flag.str());
    } else {
      std::cerr << switch_count << " keys expected from " << switch_count_key
                << ", but " << switch_key.str() << " is missing." << std::endl;
    }
  }
#endif  // !FLUTTER_RELEASE
  return switches;
}

GetSwitchValue()

template<typename T >

static bool flutter::GetSwitchValue ( const fml::CommandLine &  command_line, Switch  sw, T *  result  )

static

Definition at line 181 of file switches.cc.

                                      {
  std::string switch_string;
 
  if (!command_line.GetOptionValue(FlagForSwitch(sw), &switch_string)) {
    return false;
  }
 
  std::stringstream stream(switch_string);
  T value = 0;
  if (stream >> value) {
    *result = value;
    return true;
  }
 
  return false;
}

GetSymbolMapping()

std::unique_ptr< fml::Mapping > flutter::GetSymbolMapping	(	const std::string &	symbol_prefix,
		const std::string &	native_lib_path
	)

Definition at line 200 of file switches.cc.

                                      {
  const uint8_t* mapping = nullptr;
  intptr_t size;
 
  auto lookup_symbol = [&mapping, &size, symbol_prefix](
                           const fml::RefPtr<fml::NativeLibrary>& library) {
    mapping = library->ResolveSymbol((symbol_prefix + "_start").c_str());
    size = reinterpret_cast<intptr_t>(
        library->ResolveSymbol((symbol_prefix + "_size").c_str()));
  };
 
  fml::RefPtr<fml::NativeLibrary> library =
      fml::NativeLibrary::CreateForCurrentProcess();
  lookup_symbol(library);
 
  if (!(mapping && size)) {
    // Symbol lookup for the current process fails on some devices.  As a
    // fallback, try doing the lookup based on the path to the Flutter library.
    library = fml::NativeLibrary::Create(native_lib_path.c_str());
    lookup_symbol(library);
  }
 
  FML_CHECK(mapping && size) << "Unable to resolve symbols: " << symbol_prefix;
  return std::make_unique<fml::NonOwnedMapping>(mapping, size);
}

GetTestFontData()

std::vector< sk_sp< SkTypeface > > flutter::GetTestFontData

(

)

Definition at line 1625 of file test_font_data.cc.

                                               {
  std::vector<sk_sp<SkTypeface>> typefaces;
#if EMBED_TEST_FONT_DATA
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  typefaces.push_back(font_mgr->makeFromStream(
      SkMemoryStream::MakeDirect(kFlutterTestFont, kFlutterTestFontLength)));
  typefaces.push_back(font_mgr->makeFromStream(
      SkMemoryStream::MakeDirect(kAhemFont, kAhemFontLength)));
  typefaces.push_back(font_mgr->makeFromStream(
      SkMemoryStream::MakeDirect(kCoughFont, kCoughFontLength)));
#endif  // EMBED_TEST_FONT_DATA
  return typefaces;
}

GetTestFontFamilyNames()

std::vector< std::string > flutter::GetTestFontFamilyNames

(

)

Definition at line 1639 of file test_font_data.cc.

                                              {
  std::vector<std::string> names;
#if EMBED_TEST_FONT_DATA
  names = {"FlutterTest", "Ahem", "Cough"};
#endif  // EMBED_TEST_FONT_DATA
  return names;
}

GetTracingResult()

TracingResult flutter::GetTracingResult ( )

inline

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.

Returns

The tracing result.

Definition at line 62 of file ptrace_check.h.

                                        {
#if TRACING_CHECKS_NECESSARY
  return GetTracingResultImpl();
#else   // TRACING_CHECKS_NECESSARY
  return TracingResult::kNotNecessary;
#endif  // TRACING_CHECKS_NECESSARY
}

GetUserTimeFormat()

std::wstring flutter::GetUserTimeFormat

(

)

Definition at line 101 of file system_utils.cc.

                               {
  // Rather than do the call-allocate-call-free dance, just use a sufficiently
  // large buffer to handle any reasonable time format string.
  const int kBufferSize = 100;
  wchar_t buffer[kBufferSize];
  if (::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_STIMEFORMAT, buffer,
                        kBufferSize) == 0) {
    return std::wstring();
  }
  return std::wstring(buffer, kBufferSize);
}

GetVMServiceAssetsArchiveCallback()

Dart_Handle flutter::GetVMServiceAssetsArchiveCallback

(

)

Definition at line 163 of file dart_vm.cc.

                                                {
#if FLUTTER_RELEASE
  return nullptr;
#elif OS_FUCHSIA
  fml::UniqueFD fd = fml::OpenFile("pkg/data/observatory.tar", false,
                                   fml::FilePermission::kRead);
  fml::FileMapping mapping(fd, {fml::FileMapping::Protection::kRead});
  if (mapping.GetSize() == 0 || mapping.GetMapping() == nullptr) {
    FML_LOG(ERROR) << "Fail to load Observatory archive";
    return nullptr;
  }
  return tonic::DartConverter<tonic::Uint8List>::ToDart(mapping.GetMapping(),
                                                        mapping.GetSize());
#else
  return tonic::DartConverter<tonic::Uint8List>::ToDart(
      ::dart::observatory::observatory_assets_archive,
      ::dart::observatory::observatory_assets_archive_len);
#endif
}

glyphInfoFrom()

Dart_Handle flutter::glyphInfoFrom	(	Dart_Handle	constructor,
		const skia::textlayout::Paragraph::GlyphInfo &	glyphInfo
	)

Definition at line 123 of file paragraph.cc.

                                                       {
  std::array<Dart_Handle, 7> arguments = {
      Dart_NewDouble(glyphInfo.fGraphemeLayoutBounds.fLeft),
      Dart_NewDouble(glyphInfo.fGraphemeLayoutBounds.fTop),
      Dart_NewDouble(glyphInfo.fGraphemeLayoutBounds.fRight),
      Dart_NewDouble(glyphInfo.fGraphemeLayoutBounds.fBottom),
      Dart_NewInteger(glyphInfo.fGraphemeClusterTextRange.start),
      Dart_NewInteger(glyphInfo.fGraphemeClusterTextRange.end),
      Dart_NewBoolean(glyphInfo.fDirection ==
                      skia::textlayout::TextDirection::kLtr),
  };
  return Dart_InvokeClosure(constructor, arguments.size(), arguments.data());
}

HandleMessageOnHandler()

static bool flutter::HandleMessageOnHandler ( ServiceProtocol::Handler *  handler, std::string_view  method, const ServiceProtocol::Handler::ServiceProtocolMap &  params, rapidjson::Document *  document  )

static

Definition at line 164 of file service_protocol.cc.

                                 {
  FML_DCHECK(handler);
  fml::AutoResetWaitableEvent latch;
  bool result = false;
  fml::TaskRunner::RunNowOrPostTask(
      handler->GetServiceProtocolHandlerTaskRunner(method),
      [&latch,    //
       &result,   //
       &handler,  //
       &method,   //
       &params,   //
       &document  //
  ]() {
        result =
            handler->HandleServiceProtocolMessage(method, params, document);
        latch.Signal();
      });
  latch.Wait();
  return result;
}

ImageFromDecompressedData()

static sk_sp< SkImage > flutter::ImageFromDecompressedData ( ImageDescriptor *  descriptor, uint32_t  target_width, uint32_t  target_height, const fml::tracing::TraceFlow &  flow  )

static

Definition at line 78 of file image_decoder_skia.cc.

                                     {
  TRACE_EVENT0("flutter", __FUNCTION__);
  flow.Step(__FUNCTION__);
  auto image = SkImages::RasterFromData(
      descriptor->image_info(), descriptor->data(), descriptor->row_bytes());
 
  if (!image) {
    FML_LOG(ERROR) << "Could not create image from decompressed bytes.";
    return nullptr;
  }
 
  if (!target_width && !target_height) {
    // No resizing requested. Just rasterize the image.
    return image->makeRasterImage();
  }
 
  return ResizeRasterImage(image, SkISize::Make(target_width, target_height),
                           flow);
}

IMPLEMENT_WRAPPERTYPEINFO() [1/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	flutter_gpu	,
		FlutterGpuTestClass
	)

IMPLEMENT_WRAPPERTYPEINFO() [2/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Canvas
	)

IMPLEMENT_WRAPPERTYPEINFO() [3/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Codec
	)

IMPLEMENT_WRAPPERTYPEINFO() [4/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ColorFilter
	)

IMPLEMENT_WRAPPERTYPEINFO() [5/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		EngineLayer
	)

IMPLEMENT_WRAPPERTYPEINFO() [6/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		FragmentProgram
	)

IMPLEMENT_WRAPPERTYPEINFO() [7/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Gradient
	)

IMPLEMENT_WRAPPERTYPEINFO() [8/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImageDescriptor
	)

IMPLEMENT_WRAPPERTYPEINFO() [9/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImageFilter
	)

IMPLEMENT_WRAPPERTYPEINFO() [10/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImageShader
	)

IMPLEMENT_WRAPPERTYPEINFO() [11/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImmutableBuffer
	)

IMPLEMENT_WRAPPERTYPEINFO() [12/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		NativeStringAttribute
	)

IMPLEMENT_WRAPPERTYPEINFO() [13/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Paragraph
	)

IMPLEMENT_WRAPPERTYPEINFO() [14/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ParagraphBuilder
	)

IMPLEMENT_WRAPPERTYPEINFO() [15/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Path
	)

IMPLEMENT_WRAPPERTYPEINFO() [16/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		PathMeasure
	)

IMPLEMENT_WRAPPERTYPEINFO() [17/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Picture
	)

IMPLEMENT_WRAPPERTYPEINFO() [18/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		PictureRecorder
	)

IMPLEMENT_WRAPPERTYPEINFO() [19/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ReusableFragmentShader
	)

IMPLEMENT_WRAPPERTYPEINFO() [20/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Scene
	)

IMPLEMENT_WRAPPERTYPEINFO() [21/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SceneBuilder
	)

IMPLEMENT_WRAPPERTYPEINFO() [22/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SceneNode
	)

IMPLEMENT_WRAPPERTYPEINFO() [23/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SceneShader
	)

IMPLEMENT_WRAPPERTYPEINFO() [24/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SemanticsUpdate
	)

IMPLEMENT_WRAPPERTYPEINFO() [25/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SemanticsUpdateBuilder
	)

IMPLEMENT_WRAPPERTYPEINFO() [26/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Shader
	)

IMPLEMENT_WRAPPERTYPEINFO() [27/27]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Vertices
	)

InitDartAsync()

static void flutter::InitDartAsync ( Dart_Handle  builtin_library, bool  is_ui_isolate  )

static

Definition at line 86 of file dart_runtime_hooks.cc.

                                                                           {
  Dart_Handle schedule_microtask;
  if (is_ui_isolate) {
    schedule_microtask =
        InvokeFunction(builtin_library, "_getScheduleMicrotaskClosure");
  } else {
    Dart_Handle isolate_lib = Dart_LookupLibrary(ToDart("dart:isolate"));
    Dart_Handle method_name =
        Dart_NewStringFromCString("_getIsolateScheduleImmediateClosure");
    schedule_microtask = Dart_Invoke(isolate_lib, method_name, 0, NULL);
  }
  Dart_Handle async_library = Dart_LookupLibrary(ToDart("dart:async"));
  Dart_Handle set_schedule_microtask = ToDart("_setScheduleImmediateClosure");
  Dart_Handle result = Dart_Invoke(async_library, set_schedule_microtask, 1,
                                   &schedule_microtask);
  PropagateIfError(result);
}

InitDartCore()

static void flutter::InitDartCore ( Dart_Handle  builtin, const std::string &  script_uri  )

static

Definition at line 76 of file dart_runtime_hooks.cc.

                                                                           {
  Dart_Handle io_lib = Dart_LookupLibrary(ToDart("dart:io"));
  Dart_Handle get_base_url =
      Dart_Invoke(io_lib, ToDart("_getUriBaseClosure"), 0, NULL);
  Dart_Handle core_library = Dart_LookupLibrary(ToDart("dart:core"));
  Dart_Handle result =
      Dart_SetField(core_library, ToDart("_uriBaseClosure"), get_base_url);
  PropagateIfError(result);
}

InitDartFFIForIsolateGroup()

static void flutter::InitDartFFIForIsolateGroup ( )

static

Definition at line 1178 of file dart_isolate.cc.

                                         {
  NativeAssetsApi native_assets;
  memset(&native_assets, 0, sizeof(native_assets));
  native_assets.dlopen_absolute = &dart::bin::NativeAssets::DlopenAbsolute;
  native_assets.dlopen_relative = &NativeAssetsDlopenRelative;
  native_assets.dlopen_system = &dart::bin::NativeAssets::DlopenSystem;
  native_assets.dlopen_executable = &dart::bin::NativeAssets::DlopenExecutable;
  native_assets.dlopen_process = &dart::bin::NativeAssets::DlopenProcess;
  native_assets.dlsym = &dart::bin::NativeAssets::Dlsym;
  Dart_InitializeNativeAssetsResolver(&native_assets);
};

InitDartInternal()

static void flutter::InitDartInternal ( Dart_Handle  builtin_library, bool  is_ui_isolate  )

static

Definition at line 49 of file dart_runtime_hooks.cc.

                                                                              {
  Dart_Handle print = InvokeFunction(builtin_library, "_getPrintClosure");
 
  Dart_Handle internal_library = Dart_LookupLibrary(ToDart("dart:_internal"));
 
  Dart_Handle result =
      Dart_SetField(internal_library, ToDart("_printClosure"), print);
  PropagateIfError(result);
 
  if (is_ui_isolate) {
    // Call |_setupHooks| to configure |VMLibraryHooks|.
    Dart_Handle method_name = Dart_NewStringFromCString("_setupHooks");
    result = Dart_Invoke(builtin_library, method_name, 0, NULL);
    PropagateIfError(result);
  }
 
  Dart_Handle setup_hooks = Dart_NewStringFromCString("_setupHooks");
 
  Dart_Handle io_lib = Dart_LookupLibrary(ToDart("dart:io"));
  result = Dart_Invoke(io_lib, setup_hooks, 0, NULL);
  PropagateIfError(result);
 
  Dart_Handle isolate_lib = Dart_LookupLibrary(ToDart("dart:isolate"));
  result = Dart_Invoke(isolate_lib, setup_hooks, 0, NULL);
  PropagateIfError(result);
}

InitDartIO()

static void flutter::InitDartIO ( Dart_Handle  builtin_library, const std::string &  script_uri  )

static

Definition at line 104 of file dart_runtime_hooks.cc.

                                                    {
  Dart_Handle io_lib = Dart_LookupLibrary(ToDart("dart:io"));
  Dart_Handle platform_type =
      Dart_GetNonNullableType(io_lib, ToDart("_Platform"), 0, nullptr);
  if (!script_uri.empty()) {
    Dart_Handle result = Dart_SetField(platform_type, ToDart("_nativeScript"),
                                       ToDart(script_uri));
    PropagateIfError(result);
  }
  // typedef _LocaleClosure = String Function();
  Dart_Handle /* _LocaleClosure? */ locale_closure =
      InvokeFunction(builtin_library, "_getLocaleClosure");
  PropagateIfError(locale_closure);
  //   static String Function()? _localeClosure;
  Dart_Handle result =
      Dart_SetField(platform_type, ToDart("_localeClosure"), locale_closure);
  PropagateIfError(result);
 
#if !FLUTTER_RELEASE
  // Register dart:io service extensions used for network profiling.
  Dart_Handle network_profiling_type =
      Dart_GetNonNullableType(io_lib, ToDart("_NetworkProfiling"), 0, nullptr);
  PropagateIfError(network_profiling_type);
  result = Dart_Invoke(network_profiling_type,
                       ToDart("_registerServiceExtension"), 0, nullptr);
  PropagateIfError(result);
#endif  // !FLUTTER_RELEASE
}

InitSkiaEventTracer()

void flutter::InitSkiaEventTracer	(	bool	enabled,
		const std::optional< std::vector< std::string > > &	allowlist
	)

Definition at line 328 of file skia_event_tracer_impl.cc.

                                                        {
  auto tracer = new FlutterEventTracer(enabled, allowlist);
  // Initialize the binding to Skia's tracing events. Skia will
  // take ownership of and clean up the memory allocated here.
  SkEventTracer::SetInstance(tracer);
}

InvokeDartPluginRegistrantIfAvailable()

bool flutter::InvokeDartPluginRegistrantIfAvailable

(

Dart_Handle

library_handle

)

Looks for the Dart Plugin Registrant in library_handle and invokes it if it is found.

Returns

true when the registrant has been invoked.

Definition at line 18 of file dart_plugin_registrant.cc.

                                                                       {
  TRACE_EVENT0("flutter", "InvokeDartPluginRegistrantIfAvailable");
 
  // The Dart plugin registrant is a static method with signature `void
  // register()` within the class `_PluginRegistrant` generated by the Flutter
  // tool.
  //
  // This method binds a plugin implementation to their platform
  // interface based on the configuration of the app's pubpec.yaml, and the
  // plugin's pubspec.yaml.
  //
  // Since this method may or may not be defined, check if the class is defined
  // in the default library before calling the method.
  Dart_Handle plugin_registrant =
      ::Dart_GetClass(library_handle, tonic::ToDart("_PluginRegistrant"));
 
  if (Dart_IsError(plugin_registrant)) {
    return false;
  }
  tonic::CheckAndHandleError(
      tonic::DartInvokeField(plugin_registrant, "register", {}));
  return true;
}

InvokeFunction()

static Dart_Handle flutter::InvokeFunction ( Dart_Handle  builtin_library, const char *  name  )

static

Definition at line 43 of file dart_runtime_hooks.cc.

                                                    {
  Dart_Handle getter_name = ToDart(name);
  return Dart_Invoke(builtin_library, getter_name, 0, nullptr);
}

InvokeMainEntrypoint()

static bool flutter::InvokeMainEntrypoint ( Dart_Handle  user_entrypoint_function, Dart_Handle  args  )

static

Definition at line 858 of file dart_isolate.cc.

                      {
  if (tonic::CheckAndHandleError(user_entrypoint_function)) {
    FML_LOG(ERROR) << "Could not resolve main entrypoint function.";
    return false;
  }
 
  Dart_Handle start_main_isolate_function =
      tonic::DartInvokeField(Dart_LookupLibrary(tonic::ToDart("dart:isolate")),
                             "_getStartMainIsolateFunction", {});
 
  if (tonic::CheckAndHandleError(start_main_isolate_function)) {
    FML_LOG(ERROR) << "Could not resolve main entrypoint trampoline.";
    return false;
  }
 
  if (tonic::CheckAndHandleError(tonic::DartInvokeField(
          Dart_LookupLibrary(tonic::ToDart("dart:ui")), "_runMain",
          {start_main_isolate_function, user_entrypoint_function, args}))) {
    FML_LOG(ERROR) << "Could not invoke the main entrypoint.";
    return false;
  }
 
  return true;
}

InvokeNextFrameCallback()

static void flutter::InvokeNextFrameCallback ( const fml::RefPtr< CanvasImage > &  image, int  duration, const std::string &  decode_error, std::unique_ptr< tonic::DartPersistentValue >  callback, size_t  trace_id  )

static

Definition at line 38 of file multi_frame_codec.cc.

                     {
  std::shared_ptr<tonic::DartState> dart_state = callback->dart_state().lock();
  if (!dart_state) {
    FML_DLOG(ERROR) << "Could not acquire Dart state while attempting to fire "
                       "next frame callback.";
    return;
  }
  tonic::DartState::Scope scope(dart_state);
  tonic::DartInvoke(callback->value(),
                    {tonic::ToDart(image), tonic::ToDart(duration),
                     tonic::ToDart(decode_error)});
}

InvokePlatformMessageEmptyResponseCallback()

static void flutter::InvokePlatformMessageEmptyResponseCallback ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jint  responseId  )

static

Definition at line 544 of file platform_view_android_jni_impl.cc.

                                                                        {
  ANDROID_SHELL_HOLDER->GetPlatformMessageHandler()
      ->InvokePlatformMessageEmptyResponseCallback(responseId);
}

InvokePlatformMessageResponseCallback()

static void flutter::InvokePlatformMessageResponseCallback ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jint  responseId, jobject  message, jint  position  )

static

Definition at line 529 of file platform_view_android_jni_impl.cc.

                                                                 {
  uint8_t* response_data =
      static_cast<uint8_t*>(env->GetDirectBufferAddress(message));
  FML_DCHECK(response_data != nullptr);
  auto mapping = std::make_unique<fml::MallocMapping>(
      fml::MallocMapping::Copy(response_data, response_data + position));
  ANDROID_SHELL_HOLDER->GetPlatformMessageHandler()
      ->InvokePlatformMessageResponseCallback(responseId, std::move(mapping));
}

is_power_of_two()

static constexpr bool flutter::is_power_of_two ( int  value )

inlinestaticconstexpr

Definition at line 38 of file dl_builder.cc.

                                                        {
  return (value & (value - 1)) == 0;
}

IsAllowedDartVMFlag()

static bool flutter::IsAllowedDartVMFlag ( const std::string &  flag )

static

Definition at line 163 of file switches.cc.

                                                       {
  for (uint32_t i = 0; i < fml::size(kAllowedDartFlags); ++i) {
    const std::string& allowed = kAllowedDartFlags[i];
    // Check that the prefix of the flag matches one of the allowed flags. This
    // is to handle cases where flags take arguments, such as in
    // "--max_profile_depth 1".
    //
    // We don't need to worry about cases like "--safe --sneaky_dangerous" as
    // the VM will discard these as a single unrecognized flag.
    if (flag.length() >= allowed.length() &&
        std::equal(allowed.begin(), allowed.end(), flag.begin())) {
      return true;
    }
  }
  return false;
}

IsDisplayListWorthRasterizing()

static bool flutter::IsDisplayListWorthRasterizing ( const DisplayList *  display_list, bool  will_change, bool  is_complex, DisplayListComplexityCalculator *  complexity_calculator  )

static

Definition at line 23 of file display_list_raster_cache_item.cc.

                                                            {
  if (will_change) {
    // If the display list is going to change in the future, there is no point
    // in doing to extra work to rasterize.
    return false;
  }
 
  if (display_list == nullptr ||
      !RasterCacheUtil::CanRasterizeRect(display_list->bounds())) {
    // No point in deciding whether the display list is worth rasterizing if it
    // cannot be rasterized at all.
    return false;
  }
 
  if (is_complex) {
    // The caller seems to have extra information about the display list and
    // thinks the display list is always worth rasterizing.
    return true;
  }
 
  unsigned int complexity_score = complexity_calculator->Compute(display_list);
  return complexity_calculator->ShouldBeCached(complexity_score);
}

isEasciiPrintable()

static bool flutter::isEasciiPrintable ( int  codeUnit )

static

Definition at line 71 of file keyboard_key_embedder_handler.cc.

                                            {
  return (codeUnit <= 0x7f && codeUnit >= 0x20) ||
         (codeUnit <= 0xff && codeUnit >= 0x80);
}

IsEncodedVersionLessThanOrSame()

bool flutter::IsEncodedVersionLessThanOrSame	(	uint32_t	encoded_lhs,
		ProductVersion	rhs
	)

Definition at line 122 of file availability_version_check.cc.

                                                                              {
  // Parse the values out of encoded_lhs, then compare against rhs.
  const int32_t major = (encoded_lhs >> 16) & 0xffff;
  const int32_t minor = (encoded_lhs >> 8) & 0xff;
  const int32_t subminor = encoded_lhs & 0xff;
  auto lhs = ProductVersion{major, minor, subminor};
 
  return lhs <= rhs;
}

IsIosEmbeddedViewsPreviewEnabled()

bool flutter::IsIosEmbeddedViewsPreviewEnabled

(

)

IsProcResolverOpenGLES()

static bool flutter::IsProcResolverOpenGLES ( const GPUSurfaceGLDelegate::GLProcResolver &  proc_resolver )

static

Definition at line 56 of file gpu_surface_gl_delegate.cc.

                                                             {
  // Version string prefix that identifies an OpenGL ES implementation.
#define GPU_GL_VERSION 0x1F02
  constexpr char kGLESVersionPrefix[] = "OpenGL ES";
 
#ifdef WIN32
  using GLGetStringProc = const char*(__stdcall*)(uint32_t);
#else
  using GLGetStringProc = const char* (*)(uint32_t);
#endif
 
  GLGetStringProc gl_get_string =
      reinterpret_cast<GLGetStringProc>(proc_resolver("glGetString"));
 
  FML_CHECK(gl_get_string)
      << "The GL proc resolver could not resolve glGetString";
 
  const char* gl_version_string = gl_get_string(GPU_GL_VERSION);
 
  FML_CHECK(gl_version_string)
      << "The GL proc resolver's glGetString(GL_VERSION) failed";
 
  return strncmp(gl_version_string, kGLESVersionPrefix,
                 strlen(kGLESVersionPrefix)) == 0;
}

kSkiaCleanupExpiration()

static constexpr std::chrono::milliseconds flutter::kSkiaCleanupExpiration ( 15000  )

staticconstexpr

LineTo()

API void flutter::LineTo	(	SkPath *	path,
		SkScalar	x,
		SkScalar	y
	)

Definition at line 22 of file path_ops.cc.

                                                  {
  path->lineTo(x, y);
}

LoadDartDeferredLibrary()

static void flutter::LoadDartDeferredLibrary ( JNIEnv *  env, jobject  obj, jlong  shell_holder, jint  jLoadingUnitId, jobjectArray  jSearchPaths  )

static

Definition at line 604 of file platform_view_android_jni_impl.cc.

                                                               {
  // Convert java->c++
  intptr_t loading_unit_id = static_cast<intptr_t>(jLoadingUnitId);
  std::vector<std::string> search_paths =
      fml::jni::StringArrayToVector(env, jSearchPaths);
 
  // Use dlopen here to directly check if handle is nullptr before creating a
  // NativeLibrary.
  void* handle = nullptr;
  while (handle == nullptr && !search_paths.empty()) {
    std::string path = search_paths.back();
    handle = ::dlopen(path.c_str(), RTLD_NOW);
    search_paths.pop_back();
  }
  if (handle == nullptr) {
    LoadLoadingUnitFailure(loading_unit_id,
                           "No lib .so found for provided search paths.", true);
    return;
  }
  fml::RefPtr<fml::NativeLibrary> native_lib =
      fml::NativeLibrary::CreateWithHandle(handle, false);
 
  // Resolve symbols.
  std::unique_ptr<const fml::SymbolMapping> data_mapping =
      std::make_unique<const fml::SymbolMapping>(
          native_lib, DartSnapshot::kIsolateDataSymbol);
  std::unique_ptr<const fml::SymbolMapping> instructions_mapping =
      std::make_unique<const fml::SymbolMapping>(
          native_lib, DartSnapshot::kIsolateInstructionsSymbol);
 
  ANDROID_SHELL_HOLDER->GetPlatformView()->LoadDartDeferredLibrary(
      loading_unit_id, std::move(data_mapping),
      std::move(instructions_mapping));
}

LoadLibraryFromKernel()

EXPORTED Dart_Handle flutter::LoadLibraryFromKernel

(

const char *

path

)

Definition at line 524 of file tester_main.cc.

                                                             {
  std::shared_ptr<fml::FileMapping> mapping =
      fml::FileMapping::CreateReadOnly(path);
  if (!mapping) {
    return Dart_Null();
  }
  return DartIsolate::LoadLibraryFromKernel(mapping);
}

LoadLoadingUnitFailure()

static void flutter::LoadLoadingUnitFailure ( intptr_t  loading_unit_id, const std::string &  message, bool  transient  )

static

Definition at line 588 of file platform_view_android_jni_impl.cc.

                                                   {
  // TODO(garyq): Implement
}

LogLastEGLError()

void flutter::LogLastEGLError

(

)

Definition at line 17 of file android_egl_surface.cc.

                       {
  struct EGLNameErrorPair {
    const char* name;
    EGLint code;
  };
 
#define _EGL_ERROR_DESC(a) \
  { #a, a }
 
  const EGLNameErrorPair pairs[] = {
      _EGL_ERROR_DESC(EGL_SUCCESS),
      _EGL_ERROR_DESC(EGL_NOT_INITIALIZED),
      _EGL_ERROR_DESC(EGL_BAD_ACCESS),
      _EGL_ERROR_DESC(EGL_BAD_ALLOC),
      _EGL_ERROR_DESC(EGL_BAD_ATTRIBUTE),
      _EGL_ERROR_DESC(EGL_BAD_CONTEXT),
      _EGL_ERROR_DESC(EGL_BAD_CONFIG),
      _EGL_ERROR_DESC(EGL_BAD_CURRENT_SURFACE),
      _EGL_ERROR_DESC(EGL_BAD_DISPLAY),
      _EGL_ERROR_DESC(EGL_BAD_SURFACE),
      _EGL_ERROR_DESC(EGL_BAD_MATCH),
      _EGL_ERROR_DESC(EGL_BAD_PARAMETER),
      _EGL_ERROR_DESC(EGL_BAD_NATIVE_PIXMAP),
      _EGL_ERROR_DESC(EGL_BAD_NATIVE_WINDOW),
      _EGL_ERROR_DESC(EGL_CONTEXT_LOST),
  };
 
#undef _EGL_ERROR_DESC
 
  const auto count = sizeof(pairs) / sizeof(EGLNameErrorPair);
 
  EGLint last_error = eglGetError();
 
  for (size_t i = 0; i < count; i++) {
    if (last_error == pairs[i].code) {
      FML_LOG(ERROR) << "EGL Error: " << pairs[i].name << " (" << pairs[i].code
                     << ")";
      return;
    }
  }
 
  FML_LOG(ERROR) << "Unknown EGL Error";
}

LookupCallbackInformation()

static jobject flutter::LookupCallbackInformation ( JNIEnv *  env, jobject  , jlong  handle  )

static

Definition at line 289 of file platform_view_android_jni_impl.cc.

                                                       {
  auto cbInfo = flutter::DartCallbackCache::GetCallbackInformation(handle);
  if (cbInfo == nullptr) {
    return nullptr;
  }
  return CreateFlutterCallbackInformation(env, cbInfo->name, cbInfo->class_name,
                                          cbInfo->library_path);
}

LookupEntryPoint()

EXPORTED Dart_Handle flutter::LookupEntryPoint	(	const char *	uri,
		const char *	name
	)

Definition at line 533 of file tester_main.cc.

                                                                         {
  if (!uri || !name) {
    return Dart_Null();
  }
  Dart_Handle lib = Dart_LookupLibrary(Dart_NewStringFromCString(uri));
  if (Dart_IsError(lib)) {
    return lib;
  }
  return Dart_GetField(lib, Dart_NewStringFromCString(name));
}

MakeBackingStoreConfig()

static FlutterBackingStoreConfig flutter::MakeBackingStoreConfig ( int64_t  view_id, const SkISize &  backing_store_size  )

static

Definition at line 120 of file embedder_external_view_embedder.cc.

                                       {
  FlutterBackingStoreConfig config = {};
 
  config.struct_size = sizeof(config);
 
  config.size.width = backing_store_size.width();
  config.size.height = backing_store_size.height();
  config.view_id = view_id;
 
  return config;
}

MakeDefaultContextOptions()

GrContextOptions flutter::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.

Parameters

[in]	type	The type of context that will be created using these options.
[in]	type	The client rendering API that will be wrapped using a context with these options. This argument is only required if the context is going to be used with a particular client rendering API.

Returns

The default graphics context options.

Definition at line 13 of file context_options.cc.

                                                                          {
  GrContextOptions options;
 
  if (PersistentCache::cache_sksl()) {
    options.fShaderCacheStrategy = GrContextOptions::ShaderCacheStrategy::kSkSL;
  }
  PersistentCache::MarkStrategySet();
  options.fPersistentCache = PersistentCache::GetCacheForProcess();
 
  if (api.has_value() && api.value() == GrBackendApi::kOpenGL) {
    // Using stencil buffers has caused memory and performance regressions.
    // See b/226484927 for internal customer regressions doc.
    // Before enabling, we need to show a motivating case for where it will
    // improve performance on OpenGL backend.
    options.fAvoidStencilBuffers = true;
 
    // To get video playback on the widest range of devices, we limit Skia to
    // ES2 shading language when the ES3 external image extension is missing.
    options.fPreferExternalImagesOverES3 = true;
  }
 
  // TODO(goderbauer): remove option when skbug.com/7523 is fixed.
  options.fDisableGpuYUVConversion = true;
 
  options.fReduceOpsTaskSplitting = GrContextOptions::Enable::kNo;
 
  options.fReducedShaderVariations = false;
 
  return options;
};

MakeThreadConfig()

fml::Thread::ThreadConfig flutter::MakeThreadConfig	(	flutter::ThreadHost::Type	type,
		fml::Thread::ThreadPriority	priority
	)

Definition at line 115 of file embedder_thread_host.cc.

                                      {
  return fml::Thread::ThreadConfig(
      flutter::ThreadHost::ThreadHostConfig::MakeThreadName(type,
                                                            kFlutterThreadName),
      priority);
}

MarkTextureFrameAvailable()

static void flutter::MarkTextureFrameAvailable ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jlong  texture_id  )

static

Definition at line 517 of file platform_view_android_jni_impl.cc.

                                                        {
  ANDROID_SHELL_HOLDER->GetPlatformView()->MarkTextureFrameAvailable(
      static_cast<int64_t>(texture_id));
}

MoveTo()

API void flutter::MoveTo	(	SkPath *	path,
		SkScalar	x,
		SkScalar	y
	)

Definition at line 18 of file path_ops.cc.

                                                  {
  path->moveTo(x, y);
}

NativeActivityMain()

std::unique_ptr< NativeActivity > flutter::NativeActivityMain	(	ANativeActivity *	activity,
		std::unique_ptr< fml::Mapping >	saved_state
	)

Definition at line 43 of file gtest_activity.cc.

                                           {
  return std::make_unique<GTestActivity>(activity);
}

NativeAssetsDlopenRelative()

static void * flutter::NativeAssetsDlopenRelative ( const char *  path, char **  error  )

static

Definition at line 1169 of file dart_isolate.cc.

                                                                        {
  auto* isolate_group_data =
      static_cast<std::shared_ptr<DartIsolateGroupData>*>(
          Dart_CurrentIsolateGroupData());
  const std::string& script_uri = (*isolate_group_data)->GetAdvisoryScriptURI();
  return dart::bin::NativeAssets::DlopenRelative(path, script_uri.data(),
                                                 error);
}

normalizeScancode()

static uint16_t flutter::normalizeScancode ( int  windowsScanCode, bool  extended  )

static

Definition at line 104 of file keyboard_key_embedder_handler.cc.

                                                                      {
  // In Chromium spec the extended bit is shown as 0xe000 bit,
  // e.g. PageUp is represented as 0xe049.
  return (windowsScanCode & 0xff) | (extended ? 0xe000 : 0);
}

NotEquals() [1/4]

template<class T >

bool flutter::NotEquals	(	const T *	a,
		const T *	b
	)

Definition at line 70 of file dl_comparable.h.

                                       {
  return !Equals<T>(a, b);
}

NotEquals() [2/4]

template<class T >

bool flutter::NotEquals	(	const T *	a,
		std::shared_ptr< const T >	b
	)

Definition at line 85 of file dl_comparable.h.

                                                     {
  return !Equals(a, b.get());
}

NotEquals() [3/4]

template<class T >

bool flutter::NotEquals	(	std::shared_ptr< const T >	a,
		const T *	b
	)

Definition at line 75 of file dl_comparable.h.

                                                     {
  return !Equals(a.get(), b);
}

NotEquals() [4/4]

template<class T >

bool flutter::NotEquals	(	std::shared_ptr< const T >	a,
		std::shared_ptr< const T >	b
	)

Definition at line 95 of file dl_comparable.h.

                                                                   {
  return !Equals(a.get(), b.get());
}

NotifyLowMemoryWarning()

static void flutter::NotifyLowMemoryWarning ( JNIEnv *  env, jobject  obj, jlong  shell_holder  )

static

Definition at line 552 of file platform_view_android_jni_impl.cc.

                                                       {
  ANDROID_SHELL_HOLDER->NotifyLowMemoryWarning();
}

NumWindowsForThread()

static int64_t flutter::NumWindowsForThread ( const THREADENTRY32 &  thread )

static

Definition at line 149 of file windows_lifecycle_manager.cc.

                                                                {
  int64_t num_windows = 0;
  ::EnumThreadWindows(
      thread.th32ThreadID,
      [](HWND hwnd, LPARAM lparam) {
        int64_t* windows_ptr = reinterpret_cast<int64_t*>(lparam);
        if (::GetParent(hwnd) == nullptr) {
          (*windows_ptr)++;
        }
        return *windows_ptr <= 1 ? TRUE : FALSE;
      },
      reinterpret_cast<LPARAM>(&num_windows));
  return num_windows;
}

Op()

API void flutter::Op	(	SkPath *	one,
		SkPath *	two,
		SkPathOp	op
	)

Definition at line 44 of file path_ops.cc.

                                               {
  Op(*one, *two, op, one);
}

operator<<()

std::ostream & flutter::operator<<	(	std::ostream &	os,
		const ViewportMetrics &	a
	)

Definition at line 97 of file viewport_metrics.cc.

                                                                 {
  os << "DPR: " << a.device_pixel_ratio << " " << "Size: [" << a.physical_width
     << "W " << a.physical_height << "H] " << "Padding: ["
     << a.physical_padding_top << "T " << a.physical_padding_right << "R "
     << a.physical_padding_bottom << "B " << a.physical_padding_left << "L] "
     << "Insets: [" << a.physical_view_inset_top << "T "
     << a.physical_view_inset_right << "R " << a.physical_view_inset_bottom
     << "B " << a.physical_view_inset_left << "L] " << "Gesture Insets: ["
     << a.physical_system_gesture_inset_top << "T "
     << a.physical_system_gesture_inset_right << "R "
     << a.physical_system_gesture_inset_bottom << "B "
     << a.physical_system_gesture_inset_left << "L] "
     << "Display Features: " << a.physical_display_features_type.size() << " "
     << "Display ID: " << a.display_id;
  return os;
}

operator==() [1/2]

bool flutter::operator==	(	const LayoutGoal &	a,
		const LayoutGoal &	b
	)

Definition at line 12 of file KeyCodeMapTest.mm.

                                                          {
  return a.keyCode == b.keyCode && a.keyChar == b.keyChar && a.mandatory == b.mandatory;
}

operator==() [2/2]

bool flutter::operator==	(	const ViewportMetrics &	a,
		const ViewportMetrics &	b
	)

Definition at line 68 of file viewport_metrics.cc.

                                                                    {
  return a.device_pixel_ratio == b.device_pixel_ratio &&
         a.physical_width == b.physical_width &&
         a.physical_height == b.physical_height &&
         a.physical_padding_top == b.physical_padding_top &&
         a.physical_padding_right == b.physical_padding_right &&
         a.physical_padding_bottom == b.physical_padding_bottom &&
         a.physical_padding_left == b.physical_padding_left &&
         a.physical_view_inset_top == b.physical_view_inset_top &&
         a.physical_view_inset_right == b.physical_view_inset_right &&
         a.physical_view_inset_bottom == b.physical_view_inset_bottom &&
         a.physical_view_inset_left == b.physical_view_inset_left &&
         a.physical_system_gesture_inset_top ==
             b.physical_system_gesture_inset_top &&
         a.physical_system_gesture_inset_right ==
             b.physical_system_gesture_inset_right &&
         a.physical_system_gesture_inset_bottom ==
             b.physical_system_gesture_inset_bottom &&
         a.physical_system_gesture_inset_left ==
             b.physical_system_gesture_inset_left &&
         a.physical_touch_slop == b.physical_touch_slop &&
         a.physical_display_features_bounds ==
             b.physical_display_features_bounds &&
         a.physical_display_features_type == b.physical_display_features_type &&
         a.physical_display_features_state ==
             b.physical_display_features_state &&
         a.display_id == b.display_id;
}

ParseBase32()

sk_sp< SkData > flutter::ParseBase32

(

const std::string &

input

)

Definition at line 163 of file persistent_cache.cc.

                                                  {
  std::pair<bool, std::string> decode_result = fml::Base32Decode(input);
  if (!decode_result.first) {
    FML_LOG(ERROR) << "Base32 can't decode: " << input;
    return nullptr;
  }
  const std::string& data_string = decode_result.second;
  return SkData::MakeWithCopy(data_string.data(), data_string.length());
}

ParseBase64()

sk_sp< SkData > flutter::ParseBase64

(

const std::string &

input

)

Definition at line 173 of file persistent_cache.cc.

                                                  {
  Base64::Error error;
 
  size_t output_len;
  error = Base64::Decode(input.c_str(), input.length(), nullptr, &output_len);
  if (error != Base64::Error::kNone) {
    FML_LOG(ERROR) << "Base64 decode error: " << (int)error;
    FML_LOG(ERROR) << "Base64 can't decode: " << input;
    return nullptr;
  }
 
  sk_sp<SkData> data = SkData::MakeUninitialized(output_len);
  void* output = data->writable_data();
  error = Base64::Decode(input.c_str(), input.length(), output, &output_len);
  if (error != Base64::Error::kNone) {
    FML_LOG(ERROR) << "Base64 decode error: " << (int)error;
    FML_LOG(ERROR) << "Base64 can't decode: " << input;
    return nullptr;
  }
 
  return data;
}

ParseCommaDelimited()

static std::vector< std::string > flutter::ParseCommaDelimited ( const std::string &  input )

static

Definition at line 153 of file switches.cc.

                                                                        {
  std::istringstream ss(input);
  std::vector<std::string> result;
  std::string token;
  while (std::getline(ss, token, ',')) {
    result.push_back(token);
  }
  return result;
}

ParseKernelListPaths()

static std::vector< std::string > flutter::ParseKernelListPaths ( std::unique_ptr< fml::Mapping >  kernel_list )

static

Definition at line 148 of file isolate_configuration.cc.

                                           {
  FML_DCHECK(kernel_list);
 
  std::vector<std::string> kernel_pieces_paths;
 
  const char* kernel_list_str =
      reinterpret_cast<const char*>(kernel_list->GetMapping());
  size_t kernel_list_size = kernel_list->GetSize();
 
  size_t piece_path_start = 0;
  while (piece_path_start < kernel_list_size) {
    size_t piece_path_end = piece_path_start;
    while ((piece_path_end < kernel_list_size) &&
           (kernel_list_str[piece_path_end] != '\n')) {
      piece_path_end++;
    }
    std::string piece_path(&kernel_list_str[piece_path_start],
                           piece_path_end - piece_path_start);
    kernel_pieces_paths.emplace_back(std::move(piece_path));
 
    piece_path_start = piece_path_end + 1;
  }
 
  return kernel_pieces_paths;
}

ParseLanguageName()

LanguageInfo flutter::ParseLanguageName

(

std::wstring

language_name

)

Definition at line 71 of file system_utils.cc.

                                                         {
  LanguageInfo info;
 
  // Split by '-', discarding any suplemental language info (-x-foo).
  std::vector<std::string> components;
  std::istringstream stream(fml::WideStringToUtf8(language_name));
  std::string component;
  while (getline(stream, component, '-')) {
    if (component == "x") {
      break;
    }
    components.push_back(component);
  }
 
  // Determine which components are which.
  info.language = components[0];
  if (components.size() == 3) {
    info.script = components[1];
    info.region = components[2];
  } else if (components.size() == 2) {
    // A script code will always be four characters long.
    if (components[1].size() == 4) {
      info.script = components[1];
    } else {
      info.region = components[1];
    }
  }
  return info;
}

PersistentCacheStore()

static void flutter::PersistentCacheStore ( const fml::RefPtr< fml::TaskRunner > &  worker, const std::shared_ptr< fml::UniqueFD > &  cache_directory, std::string  key, std::unique_ptr< fml::Mapping >  value  )

static

Definition at line 349 of file persistent_cache.cc.

                                     {
  // The static leak checker gets confused by the use of fml::MakeCopyable.
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
  auto task = fml::MakeCopyable([cache_directory,             //
                                 file_name = std::move(key),  //
                                 mapping = std::move(value)   //
  ]() mutable {
    TRACE_EVENT0("flutter", "PersistentCacheStore");
    if (!fml::WriteAtomically(*cache_directory,   //
                              file_name.c_str(),  //
                              *mapping)           //
    ) {
      FML_LOG(WARNING) << "Could not write cache contents to persistent store.";
    }
  });
 
  if (!worker) {
    FML_LOG(WARNING)
        << "The persistent cache has no available workers. Performing the task "
           "on the current thread. This slow operation is going to occur on a "
           "frame workload.";
    task();
  } else {
    worker->PostTask(std::move(task));
  }
}

Prefer24HourTime()

bool flutter::Prefer24HourTime

(

std::wstring

time_format

)

Definition at line 113 of file system_utils.cc.

                                              {
  return time_format.find(L"H") != std::wstring::npos;
}

PrefetchDefaultFontManager()

static void flutter::PrefetchDefaultFontManager ( JNIEnv *  env, jclass  jcaller  )

static

Definition at line 204 of file flutter_main.cc.

                                                                    {
  // Initialize a singleton owned by Skia.
  txt::GetDefaultFontManager();
}

PrepareKernelMappings()

static std::vector< std::future< std::unique_ptr< const fml::Mapping > > > flutter::PrepareKernelMappings ( const std::vector< std::string > &  kernel_pieces_paths, const std::shared_ptr< AssetManager > &  asset_manager, const fml::RefPtr< fml::TaskRunner > &  io_worker  )

static

Definition at line 176 of file isolate_configuration.cc.

                                                                 {
  FML_DCHECK(asset_manager);
  std::vector<std::future<std::unique_ptr<const fml::Mapping>>> fetch_futures;
 
  for (const auto& kernel_pieces_path : kernel_pieces_paths) {
    std::promise<std::unique_ptr<const fml::Mapping>> fetch_promise;
    fetch_futures.push_back(fetch_promise.get_future());
    auto fetch_task =
        fml::MakeCopyable([asset_manager, kernel_pieces_path,
                           fetch_promise = std::move(fetch_promise)]() mutable {
          fetch_promise.set_value(
              asset_manager->GetAsMapping(kernel_pieces_path));
        });
    // Fulfill the promise on the worker if one is available or the current
    // thread if one is not.
    if (io_worker) {
      io_worker->PostTask(fetch_task);
    } else {
      fetch_task();
    }
  }
 
  return fetch_futures;
}

PrintUsage()

void flutter::PrintUsage

(

const std::string &

executable_name

)

Definition at line 90 of file switches.cc.

                                                  {
  std::cerr << std::endl << "  " << executable_name << std::endl << std::endl;
 
  std::cerr << "Versions: " << std::endl << std::endl;
 
  std::cerr << "Flutter Engine Version: " << GetFlutterEngineVersion()
            << std::endl;
  std::cerr << "Skia Version: " << GetSkiaVersion() << std::endl;
 
  std::cerr << "Dart Version: " << GetDartVersion() << std::endl << std::endl;
 
  std::cerr << "Available Flags:" << std::endl;
 
  const uint32_t column_width = 80;
 
  const uint32_t flags_count = static_cast<uint32_t>(Switch::Sentinel);
 
  uint32_t max_width = 2;
  for (uint32_t i = 0; i < flags_count; i++) {
    auto desc = gSwitchDescs[i];
    max_width = std::max<uint32_t>(desc.flag.size() + 2, max_width);
  }
 
  const uint32_t help_width = column_width - max_width - 3;
 
  std::cerr << std::string(column_width, '-') << std::endl;
  for (uint32_t i = 0; i < flags_count; i++) {
    auto desc = gSwitchDescs[i];
 
    std::cerr << std::setw(max_width)
              << std::string("--") +
                     std::string{desc.flag.data(), desc.flag.size()}
              << " : ";
 
    std::istringstream stream(desc.help);
    int32_t remaining = help_width;
 
    std::string word;
    while (stream >> word && remaining > 0) {
      remaining -= (word.size() + 1);
      if (remaining <= 0) {
        std::cerr << std::endl
                  << std::string(max_width, ' ') << "   " << word << " ";
        remaining = help_width;
      } else {
        std::cerr << word << " ";
      }
    }
 
    std::cerr << std::endl;
  }
  std::cerr << std::string(column_width, '-') << std::endl;
}

ProductVersionFromSystemVersionPList()

std::optional< ProductVersion > flutter::ProductVersionFromSystemVersionPList

(

)

Definition at line 53 of file availability_version_check.cc.

                                                                   {
  std::string plist_path = "/System/Library/CoreServices/SystemVersion.plist";
#if FML_OS_IOS_SIMULATOR
  char* plist_path_prefix = getenv("IPHONE_SIMULATOR_ROOT");
  if (!plist_path_prefix) {
    FML_DLOG(ERROR) << "Failed to getenv IPHONE_SIMULATOR_ROOT";
    return std::nullopt;
  }
  plist_path = std::string(plist_path_prefix) + plist_path;
#endif  // FML_OS_IOS_SIMULATOR
 
  auto plist_mapping = fml::FileMapping::CreateReadOnly(plist_path);
 
  // Get the file buffer into CF's format. We pass in a null allocator here *
  // because we free PListBuf ourselves
  auto file_contents = fml::CFRef<CFDataRef>(CFDataCreateWithBytesNoCopy(
      nullptr, plist_mapping->GetMapping(),
      static_cast<CFIndex>(plist_mapping->GetSize()), kCFAllocatorNull));
  if (!file_contents) {
    FML_DLOG(ERROR) << "Failed to CFDataCreateWithBytesNoCopyFunc";
    return std::nullopt;
  }
 
  auto plist = fml::CFRef<CFDictionaryRef>(
      reinterpret_cast<CFDictionaryRef>(CFPropertyListCreateWithData(
          nullptr, file_contents, CF_PROPERTY_LIST_IMMUTABLE, nullptr,
          nullptr)));
  if (!plist) {
    FML_DLOG(ERROR) << "Failed to CFPropertyListCreateWithDataFunc or "
                       "CFPropertyListCreateFromXMLDataFunc";
    return std::nullopt;
  }
 
  auto product_version =
      fml::CFRef<CFStringRef>(CFStringCreateWithCStringNoCopy(
          nullptr, "ProductVersion", kCFStringEncodingASCII, kCFAllocatorNull));
  if (!product_version) {
    FML_DLOG(ERROR) << "Failed to CFStringCreateWithCStringNoCopyFunc";
    return std::nullopt;
  }
  CFTypeRef opaque_value = CFDictionaryGetValue(plist, product_version);
  if (!opaque_value || CFGetTypeID(opaque_value) != CFStringGetTypeID()) {
    FML_DLOG(ERROR) << "Failed to CFDictionaryGetValueFunc";
    return std::nullopt;
  }
 
  char version_str[32];
  if (!CFStringGetCString(reinterpret_cast<CFStringRef>(opaque_value),
                          version_str, sizeof(version_str),
                          kCFStringEncodingUTF8)) {
    FML_DLOG(ERROR) << "Failed to CFStringGetCStringFunc";
    return std::nullopt;
  }
 
  int32_t major = 0;
  int32_t minor = 0;
  int32_t subminor = 0;
  int matches = sscanf(version_str, "%d.%d.%d", &major, &minor, &subminor);
  // A major version number is sufficient. The minor and subminor numbers might
  // not be present.
  if (matches < 1) {
    FML_DLOG(ERROR) << "Failed to match product version string: "
                    << version_str;
    return std::nullopt;
  }
 
  return ProductVersion{major, minor, subminor};
}

ProfilingFlags()

static std::vector< const char * > flutter::ProfilingFlags ( bool  enable_profiling )

static

Definition at line 209 of file dart_vm.cc.

                                                                    {
// Disable Dart's built in profiler when building a debug build. This
// works around a race condition that would sometimes stop a crash's
// stack trace from being printed on Android.
#ifndef NDEBUG
  enable_profiling = false;
#endif
 
  // We want to disable profiling by default because it overwhelms LLDB. But
  // the VM enables the same by default. In either case, we have some profiling
  // flags.
  if (enable_profiling) {
    return {
        // This is the default. But just be explicit.
        "--profiler",
        // This instructs the profiler to walk C++ frames, and to include
        // them in the profile.
        "--profile-vm",
#if FML_OS_IOS && FML_ARCH_CPU_ARM_FAMILY && FML_ARCH_CPU_ARMEL
        // Set the profiler interrupt period to 500Hz instead of the
        // default 1000Hz on 32-bit iOS devices to reduce average and worst
        // case frame build times.
        //
        // Note: profile_period is time in microseconds between sampling
        // events, not frequency. Frequency is calculated 1/period (or
        // 1,000,000 / 2,000 -> 500Hz in this case).
        "--profile_period=2000",
#else
        "--profile_period=1000",
#endif  // FML_OS_IOS && FML_ARCH_CPU_ARM_FAMILY && FML_ARCH_CPU_ARMEL
    };
  } else {
    return {"--no-profiler"};
  }
}

PropagateIfError()

static void flutter::PropagateIfError ( Dart_Handle  result )

static

Definition at line 36 of file dart_runtime_hooks.cc.

                                                 {
  if (Dart_IsError(result)) {
    FML_LOG(ERROR) << "Dart Error: " << ::Dart_GetError(result);
    Dart_PropagateError(result);
  }
}

ProtectEmpty() [1/3]

static const DlRect & flutter::ProtectEmpty ( const DlRect &  rect )

static

Definition at line 28 of file dl_matrix_clip_tracker.cc.

                                                      {
  // isEmpty protects us against NaN while we normalize any empty cull rects
  return rect.IsEmpty() ? kEmpty : rect;
}

ProtectEmpty() [2/3]

static const DlRect & flutter::ProtectEmpty ( const SkRect &  rect )

static

Definition at line 119 of file dl_builder.cc.

                                                      {
  // isEmpty protects us against NaN while we normalize any empty cull rects
  return rect.isEmpty() ? kEmpty : ToDlRect(rect);
}

ProtectEmpty() [3/3]

static const DlRect & flutter::ProtectEmpty ( const SkRect &  rect )

static

Definition at line 23 of file dl_matrix_clip_tracker.cc.

                                                      {
  // isEmpty protects us against NaN while we normalize any empty cull rects
  return rect.isEmpty() ? kEmpty : ToDlRect(rect);
}

PushBackAll()

void flutter::PushBackAll	(	std::vector< const char * > *	args,
		const char **	argv,
		size_t	argc
	)

Definition at line 245 of file dart_vm.cc.

                              {
  for (size_t i = 0; i < argc; ++i) {
    args->push_back(argv[i]);
  }
}

pushStringAttributes()

void flutter::pushStringAttributes	(	StringAttributes &	destination,
		const std::vector< NativeStringAttribute * > &	native_attributes
	)

Definition at line 19 of file semantics_update_builder.cc.

                                                                {
  for (const auto& native_attribute : native_attributes) {
    destination.push_back(native_attribute->GetAttribute());
  }
}

putStringAttributesIntoBuffer()

void flutter::putStringAttributesIntoBuffer	(	const StringAttributes &	attributes,
		int32_t *	buffer_int32,
		size_t &	position,
		std::vector< std::vector< uint8_t > > &	string_attribute_args
	)

Definition at line 11 of file platform_view_android_delegate.cc.

                                                          {
  if (attributes.empty()) {
    buffer_int32[position++] = -1;
    return;
  }
  buffer_int32[position++] = attributes.size();
  for (const auto& attribute : attributes) {
    buffer_int32[position++] = attribute->start;
    buffer_int32[position++] = attribute->end;
    buffer_int32[position++] = static_cast<int32_t>(attribute->type);
    switch (attribute->type) {
      case StringAttributeType::kSpellOut:
        buffer_int32[position++] = -1;
        break;
      case StringAttributeType::kLocale:
        buffer_int32[position++] = string_attribute_args.size();
        std::shared_ptr<LocaleStringAttribute> locale_attribute =
            std::static_pointer_cast<LocaleStringAttribute>(attribute);
        string_attribute_args.push_back(
            {locale_attribute->locale.begin(), locale_attribute->locale.end()});
        break;
    }
  }
}

Rasterize()

bool flutter::Rasterize	(	RasterCacheItem::CacheState	cache_state,
		Layer *	layer,
		const PaintContext &	paint_context,
		DlCanvas *	canvas
	)

Definition at line 104 of file layer_raster_cache_item.cc.

                                 {
  FML_DCHECK(cache_state != RasterCacheItem::CacheState::kNone);
  LayerStateStack state_stack;
  state_stack.set_delegate(canvas);
  PaintContext context = {
      // clang-format off
      .state_stack                   = state_stack,
      .canvas                        = canvas,
      .gr_context                    = paint_context.gr_context,
      .dst_color_space               = paint_context.dst_color_space,
      .view_embedder                 = paint_context.view_embedder,
      .raster_time                   = paint_context.raster_time,
      .ui_time                       = paint_context.ui_time,
      .texture_registry              = paint_context.texture_registry,
      .raster_cache                  = paint_context.raster_cache,
      // clang-format on
  };
 
  switch (cache_state) {
    case RasterCacheItem::CacheState::kCurrent:
      FML_DCHECK(layer->needs_painting(context));
      layer->Paint(context);
      break;
    case RasterCacheItem::CacheState::kChildren:
      layer->PaintChildren(context);
      break;
    case RasterCacheItem::CacheState::kNone:
      FML_DCHECK(cache_state != RasterCacheItem::CacheState::kNone);
      return false;
  }
  return true;
}

RegisterApi()

bool flutter::RegisterApi

(

JNIEnv *

env

)

Definition at line 658 of file platform_view_android_jni_impl.cc.

                              {
  static const JNINativeMethod flutter_jni_methods[] = {
      // Start of methods from FlutterJNI
      {
          .name = "nativeAttach",
          .signature = "(Lio/flutter/embedding/engine/FlutterJNI;)J",
          .fnPtr = reinterpret_cast<void*>(&AttachJNI),
      },
      {
          .name = "nativeDestroy",
          .signature = "(J)V",
          .fnPtr = reinterpret_cast<void*>(&DestroyJNI),
      },
      {
          .name = "nativeSpawn",
          .signature = "(JLjava/lang/String;Ljava/lang/String;Ljava/lang/"
                       "String;Ljava/util/List;)Lio/flutter/"
                       "embedding/engine/FlutterJNI;",
          .fnPtr = reinterpret_cast<void*>(&SpawnJNI),
      },
      {
          .name = "nativeRunBundleAndSnapshotFromLibrary",
          .signature = "(JLjava/lang/String;Ljava/lang/String;"
                       "Ljava/lang/String;Landroid/content/res/"
                       "AssetManager;Ljava/util/List;)V",
          .fnPtr = reinterpret_cast<void*>(&RunBundleAndSnapshotFromLibrary),
      },
      {
          .name = "nativeDispatchEmptyPlatformMessage",
          .signature = "(JLjava/lang/String;I)V",
          .fnPtr = reinterpret_cast<void*>(&DispatchEmptyPlatformMessage),
      },
      {
          .name = "nativeCleanupMessageData",
          .signature = "(J)V",
          .fnPtr = reinterpret_cast<void*>(&CleanupMessageData),
      },
      {
          .name = "nativeDispatchPlatformMessage",
          .signature = "(JLjava/lang/String;Ljava/nio/ByteBuffer;II)V",
          .fnPtr = reinterpret_cast<void*>(&DispatchPlatformMessage),
      },
      {
          .name = "nativeInvokePlatformMessageResponseCallback",
          .signature = "(JILjava/nio/ByteBuffer;I)V",
          .fnPtr =
              reinterpret_cast<void*>(&InvokePlatformMessageResponseCallback),
      },
      {
          .name = "nativeInvokePlatformMessageEmptyResponseCallback",
          .signature = "(JI)V",
          .fnPtr = reinterpret_cast<void*>(
              &InvokePlatformMessageEmptyResponseCallback),
      },
      {
          .name = "nativeNotifyLowMemoryWarning",
          .signature = "(J)V",
          .fnPtr = reinterpret_cast<void*>(&NotifyLowMemoryWarning),
      },
 
      // Start of methods from FlutterView
      {
          .name = "nativeGetBitmap",
          .signature = "(J)Landroid/graphics/Bitmap;",
          .fnPtr = reinterpret_cast<void*>(&GetBitmap),
      },
      {
          .name = "nativeSurfaceCreated",
          .signature = "(JLandroid/view/Surface;)V",
          .fnPtr = reinterpret_cast<void*>(&SurfaceCreated),
      },
      {
          .name = "nativeSurfaceWindowChanged",
          .signature = "(JLandroid/view/Surface;)V",
          .fnPtr = reinterpret_cast<void*>(&SurfaceWindowChanged),
      },
      {
          .name = "nativeSurfaceChanged",
          .signature = "(JII)V",
          .fnPtr = reinterpret_cast<void*>(&SurfaceChanged),
      },
      {
          .name = "nativeSurfaceDestroyed",
          .signature = "(J)V",
          .fnPtr = reinterpret_cast<void*>(&SurfaceDestroyed),
      },
      {
          .name = "nativeSetViewportMetrics",
          .signature = "(JFIIIIIIIIIIIIIII[I[I[I)V",
          .fnPtr = reinterpret_cast<void*>(&SetViewportMetrics),
      },
      {
          .name = "nativeDispatchPointerDataPacket",
          .signature = "(JLjava/nio/ByteBuffer;I)V",
          .fnPtr = reinterpret_cast<void*>(&DispatchPointerDataPacket),
      },
      {
          .name = "nativeDispatchSemanticsAction",
          .signature = "(JIILjava/nio/ByteBuffer;I)V",
          .fnPtr = reinterpret_cast<void*>(&DispatchSemanticsAction),
      },
      {
          .name = "nativeSetSemanticsEnabled",
          .signature = "(JZ)V",
          .fnPtr = reinterpret_cast<void*>(&SetSemanticsEnabled),
      },
      {
          .name = "nativeSetAccessibilityFeatures",
          .signature = "(JI)V",
          .fnPtr = reinterpret_cast<void*>(&SetAccessibilityFeatures),
      },
      {
          .name = "nativeGetIsSoftwareRenderingEnabled",
          .signature = "()Z",
          .fnPtr = reinterpret_cast<void*>(&GetIsSoftwareRendering),
      },
      {
          .name = "nativeRegisterTexture",
          .signature = "(JJLjava/lang/ref/"
                       "WeakReference;)V",
          .fnPtr = reinterpret_cast<void*>(&RegisterTexture),
      },
      {
          .name = "nativeRegisterImageTexture",
          .signature = "(JJLjava/lang/ref/"
                       "WeakReference;)V",
          .fnPtr = reinterpret_cast<void*>(&RegisterImageTexture),
      },
      {
          .name = "nativeMarkTextureFrameAvailable",
          .signature = "(JJ)V",
          .fnPtr = reinterpret_cast<void*>(&MarkTextureFrameAvailable),
      },
      {
          .name = "nativeScheduleFrame",
          .signature = "(J)V",
          .fnPtr = reinterpret_cast<void*>(&ScheduleFrame),
      },
      {
          .name = "nativeUnregisterTexture",
          .signature = "(JJ)V",
          .fnPtr = reinterpret_cast<void*>(&UnregisterTexture),
      },
      // Methods for Dart callback functionality.
      {
          .name = "nativeLookupCallbackInformation",
          .signature = "(J)Lio/flutter/view/FlutterCallbackInformation;",
          .fnPtr = reinterpret_cast<void*>(&LookupCallbackInformation),
      },
 
      // Start of methods for FlutterTextUtils
      {
          .name = "nativeFlutterTextUtilsIsEmoji",
          .signature = "(I)Z",
          .fnPtr = reinterpret_cast<void*>(&FlutterTextUtilsIsEmoji),
      },
      {
          .name = "nativeFlutterTextUtilsIsEmojiModifier",
          .signature = "(I)Z",
          .fnPtr = reinterpret_cast<void*>(&FlutterTextUtilsIsEmojiModifier),
      },
      {
          .name = "nativeFlutterTextUtilsIsEmojiModifierBase",
          .signature = "(I)Z",
          .fnPtr =
              reinterpret_cast<void*>(&FlutterTextUtilsIsEmojiModifierBase),
      },
      {
          .name = "nativeFlutterTextUtilsIsVariationSelector",
          .signature = "(I)Z",
          .fnPtr =
              reinterpret_cast<void*>(&FlutterTextUtilsIsVariationSelector),
      },
      {
          .name = "nativeFlutterTextUtilsIsRegionalIndicator",
          .signature = "(I)Z",
          .fnPtr =
              reinterpret_cast<void*>(&FlutterTextUtilsIsRegionalIndicator),
      },
      {
          .name = "nativeLoadDartDeferredLibrary",
          .signature = "(JI[Ljava/lang/String;)V",
          .fnPtr = reinterpret_cast<void*>(&LoadDartDeferredLibrary),
      },
      {
          .name = "nativeUpdateJavaAssetManager",
          .signature =
              "(JLandroid/content/res/AssetManager;Ljava/lang/String;)V",
          .fnPtr = reinterpret_cast<void*>(&UpdateJavaAssetManager),
      },
      {
          .name = "nativeDeferredComponentInstallFailure",
          .signature = "(ILjava/lang/String;Z)V",
          .fnPtr = reinterpret_cast<void*>(&DeferredComponentInstallFailure),
      },
      {
          .name = "nativeUpdateDisplayMetrics",
          .signature = "(J)V",
          .fnPtr = reinterpret_cast<void*>(&UpdateDisplayMetrics),
      },
  };
 
  if (env->RegisterNatives(g_flutter_jni_class->obj(), flutter_jni_methods,
                           fml::size(flutter_jni_methods)) != 0) {
    FML_LOG(ERROR) << "Failed to RegisterNatives with FlutterJNI";
    return false;
  }
 
  g_jni_shell_holder_field = env->GetFieldID(
      g_flutter_jni_class->obj(), "nativeShellHolderId", "Ljava/lang/Long;");
 
  if (g_jni_shell_holder_field == nullptr) {
    FML_LOG(ERROR) << "Could not locate FlutterJNI's nativeShellHolderId field";
    return false;
  }
 
  g_jni_constructor =
      env->GetMethodID(g_flutter_jni_class->obj(), "<init>", "()V");
 
  if (g_jni_constructor == nullptr) {
    FML_LOG(ERROR) << "Could not locate FlutterJNI's constructor";
    return false;
  }
 
  g_long_constructor = env->GetStaticMethodID(g_java_long_class->obj(),
                                              "valueOf", "(J)Ljava/lang/Long;");
  if (g_long_constructor == nullptr) {
    FML_LOG(ERROR) << "Could not locate Long's constructor";
    return false;
  }
 
  g_handle_platform_message_method =
      env->GetMethodID(g_flutter_jni_class->obj(), "handlePlatformMessage",
                       "(Ljava/lang/String;Ljava/nio/ByteBuffer;IJ)V");
 
  if (g_handle_platform_message_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate handlePlatformMessage method";
    return false;
  }
 
  g_handle_platform_message_response_method = env->GetMethodID(
      g_flutter_jni_class->obj(), "handlePlatformMessageResponse",
      "(ILjava/nio/ByteBuffer;)V");
 
  if (g_handle_platform_message_response_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate handlePlatformMessageResponse method";
    return false;
  }
 
  g_get_scaled_font_size_method = env->GetMethodID(
      g_flutter_jni_class->obj(), "getScaledFontSize", "(FI)F");
 
  if (g_get_scaled_font_size_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate FlutterJNI#getScaledFontSize method";
    return false;
  }
 
  g_update_semantics_method = env->GetMethodID(
      g_flutter_jni_class->obj(), "updateSemantics",
      "(Ljava/nio/ByteBuffer;[Ljava/lang/String;[Ljava/nio/ByteBuffer;)V");
 
  if (g_update_semantics_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate updateSemantics method";
    return false;
  }
 
  g_update_custom_accessibility_actions_method = env->GetMethodID(
      g_flutter_jni_class->obj(), "updateCustomAccessibilityActions",
      "(Ljava/nio/ByteBuffer;[Ljava/lang/String;)V");
 
  if (g_update_custom_accessibility_actions_method == nullptr) {
    FML_LOG(ERROR)
        << "Could not locate updateCustomAccessibilityActions method";
    return false;
  }
 
  g_on_first_frame_method =
      env->GetMethodID(g_flutter_jni_class->obj(), "onFirstFrame", "()V");
 
  if (g_on_first_frame_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate onFirstFrame method";
    return false;
  }
 
  g_on_engine_restart_method =
      env->GetMethodID(g_flutter_jni_class->obj(), "onPreEngineRestart", "()V");
 
  if (g_on_engine_restart_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate onEngineRestart method";
    return false;
  }
 
  g_create_overlay_surface_method =
      env->GetMethodID(g_flutter_jni_class->obj(), "createOverlaySurface",
                       "()Lio/flutter/embedding/engine/FlutterOverlaySurface;");
 
  if (g_create_overlay_surface_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate createOverlaySurface method";
    return false;
  }
 
  g_destroy_overlay_surfaces_method = env->GetMethodID(
      g_flutter_jni_class->obj(), "destroyOverlaySurfaces", "()V");
 
  if (g_destroy_overlay_surfaces_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate destroyOverlaySurfaces method";
    return false;
  }
 
  fml::jni::ScopedJavaLocalRef<jclass> overlay_surface_class(
      env, env->FindClass("io/flutter/embedding/engine/FlutterOverlaySurface"));
  if (overlay_surface_class.is_null()) {
    FML_LOG(ERROR) << "Could not locate FlutterOverlaySurface class";
    return false;
  }
  g_overlay_surface_id_method =
      env->GetMethodID(overlay_surface_class.obj(), "getId", "()I");
  if (g_overlay_surface_id_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate FlutterOverlaySurface#getId() method";
    return false;
  }
  g_overlay_surface_surface_method = env->GetMethodID(
      overlay_surface_class.obj(), "getSurface", "()Landroid/view/Surface;");
  if (g_overlay_surface_surface_method == nullptr) {
    FML_LOG(ERROR)
        << "Could not locate FlutterOverlaySurface#getSurface() method";
    return false;
  }
 
  g_bitmap_class = new fml::jni::ScopedJavaGlobalRef<jclass>(
      env, env->FindClass("android/graphics/Bitmap"));
  if (g_bitmap_class->is_null()) {
    FML_LOG(ERROR) << "Could not locate Bitmap Class";
    return false;
  }
 
  g_bitmap_create_bitmap_method = env->GetStaticMethodID(
      g_bitmap_class->obj(), "createBitmap",
      "(IILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;");
  if (g_bitmap_create_bitmap_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate Bitmap.createBitmap method";
    return false;
  }
 
  g_bitmap_copy_pixels_from_buffer_method = env->GetMethodID(
      g_bitmap_class->obj(), "copyPixelsFromBuffer", "(Ljava/nio/Buffer;)V");
  if (g_bitmap_copy_pixels_from_buffer_method == nullptr) {
    FML_LOG(ERROR) << "Could not locate Bitmap.copyPixelsFromBuffer method";
    return false;
  }
 
  g_bitmap_config_class = new fml::jni::ScopedJavaGlobalRef<jclass>(
      env, env->FindClass("android/graphics/Bitmap$Config"));
  if (g_bitmap_config_class->is_null()) {
    FML_LOG(ERROR) << "Could not locate Bitmap.Config Class";
    return false;
  }
 
  g_bitmap_config_value_of = env->GetStaticMethodID(
      g_bitmap_config_class->obj(), "valueOf",
      "(Ljava/lang/String;)Landroid/graphics/Bitmap$Config;");
  if (g_bitmap_config_value_of == nullptr) {
    FML_LOG(ERROR) << "Could not locate Bitmap.Config.valueOf method";
    return false;
  }
 
  return true;
}

RegisterImageTexture()

static void flutter::RegisterImageTexture ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jlong  texture_id, jobject  image_texture_entry  )

static

Definition at line 498 of file platform_view_android_jni_impl.cc.

                                                              {
  ANDROID_SHELL_HOLDER->GetPlatformView()->RegisterImageTexture(
      static_cast<int64_t>(texture_id),                                 //
      fml::jni::ScopedJavaGlobalRef<jobject>(env, image_texture_entry)  //
  );
}

RegisterTexture()

static void flutter::RegisterTexture ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jlong  texture_id, jobject  surface_texture  )

static

Definition at line 487 of file platform_view_android_jni_impl.cc.

                                                     {
  ANDROID_SHELL_HOLDER->GetPlatformView()->RegisterExternalTexture(
      static_cast<int64_t>(texture_id),                             //
      fml::jni::ScopedJavaGlobalRef<jobject>(env, surface_texture)  //
  );
}

RenderFrameForScreenshot()

static void flutter::RenderFrameForScreenshot ( flutter::CompositorContext &  compositor_context, DlCanvas *  canvas, flutter::LayerTree *  tree, GrDirectContext *  surface_context, const std::shared_ptr< impeller::AiksContext > &  aiks_context  )

static

Definition at line 861 of file rasterizer.cc.

                                                            {
  // There is no root surface transformation for the screenshot layer. Reset
  // the matrix to identity.
  SkMatrix root_surface_transformation;
  root_surface_transformation.reset();
 
  auto frame = compositor_context.AcquireFrame(
      /*gr_context=*/surface_context,
      /*canvas=*/canvas,
      /*view_embedder=*/nullptr,
      /*root_surface_transformation=*/root_surface_transformation,
      /*instrumentation_enabled=*/false,
      /*surface_supports_readback=*/true,
      /*raster_thread_merger=*/nullptr,
      /*aiks_context=*/aiks_context.get());
  canvas->Clear(DlColor::kTransparent());
  frame->Raster(*tree, true, nullptr);
  canvas->Flush();
}

Reset()

API void flutter::Reset

(

SkPath *

path

)

Definition at line 40 of file path_ops.cc.

                         {
  path->reset();
}

ResetAnchor()

void flutter::ResetAnchor

(

CALayer *

layer

)

Definition at line 58 of file FlutterPlatformViews_Internal.mm.

                                 {
  // Flow uses (0, 0) to apply transform matrix so we need to match that in Quartz.
  layer.anchorPoint = CGPointZero;
  layer.position = CGPointZero;
}

ResizeRasterImage()

static sk_sp< SkImage > flutter::ResizeRasterImage ( const sk_sp< SkImage > &  image, const SkISize &  resized_dimensions, const fml::tracing::TraceFlow &  flow  )

static

Definition at line 30 of file image_decoder_skia.cc.

                                                                         {
  FML_DCHECK(!image->isTextureBacked());
 
  TRACE_EVENT0("flutter", __FUNCTION__);
  flow.Step(__FUNCTION__);
 
  if (resized_dimensions.isEmpty()) {
    FML_LOG(ERROR) << "Could not resize to empty dimensions.";
    return nullptr;
  }
 
  if (image->dimensions() == resized_dimensions) {
    return image->makeRasterImage();
  }
 
  const auto scaled_image_info =
      image->imageInfo().makeDimensions(resized_dimensions);
 
  SkBitmap scaled_bitmap;
  if (!scaled_bitmap.tryAllocPixels(scaled_image_info)) {
    FML_LOG(ERROR) << "Failed to allocate memory for bitmap of size "
                   << scaled_image_info.computeMinByteSize() << "B";
    return nullptr;
  }
 
  if (!image->scalePixels(
          scaled_bitmap.pixmap(),
          SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone),
          SkImage::kDisallow_CachingHint)) {
    FML_LOG(ERROR) << "Could not scale pixels";
    return nullptr;
  }
 
  // Marking this as immutable makes the MakeFromBitmap call share the pixels
  // instead of copying.
  scaled_bitmap.setImmutable();
 
  auto scaled_image = SkImages::RasterFromBitmap(scaled_bitmap);
  if (!scaled_image) {
    FML_LOG(ERROR) << "Could not create a scaled image from a scaled bitmap.";
    return nullptr;
  }
 
  return scaled_image;
}

ResolveIsolateData()

static std::shared_ptr< const fml::Mapping > flutter::ResolveIsolateData ( const Settings &  settings )

static

Definition at line 140 of file dart_snapshot.cc.

                              {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(kDartIsolateSnapshotData,
                                                0,        // size
                                                nullptr,  // release_func
                                                true      // dontneed_safe
  );
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.isolate_snapshot_data,       // embedder_mapping_callback
      settings.isolate_snapshot_data_path,  // file_path
      settings.application_library_path,    // native_library_path
      DartSnapshot::kIsolateDataSymbol,     // native_library_symbol_name
      false                                 // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

ResolveIsolateInstructions()

static std::shared_ptr< const fml::Mapping > flutter::ResolveIsolateInstructions ( const Settings &  settings )

static

Definition at line 159 of file dart_snapshot.cc.

                              {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(
      kDartIsolateSnapshotInstructions,
      0,        // size
      nullptr,  // release_func
      true      // dontneed_safe
  );
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.isolate_snapshot_instr,           // embedder_mapping_callback
      settings.isolate_snapshot_instr_path,      // file_path
      settings.application_library_path,         // native_library_path
      DartSnapshot::kIsolateInstructionsSymbol,  // native_library_symbol_name
      true                                       // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

ResolveVMData()

static std::shared_ptr< const fml::Mapping > flutter::ResolveVMData ( const Settings &  settings )

static

Definition at line 102 of file dart_snapshot.cc.

                              {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(kDartVmSnapshotData,
                                                0,        // size
                                                nullptr,  // release_func
                                                true      // dontneed_safe
  );
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.vm_snapshot_data,          // embedder_mapping_callback
      settings.vm_snapshot_data_path,     // file_path
      settings.application_library_path,  // native_library_path
      DartSnapshot::kVMDataSymbol,        // native_library_symbol_name
      false                               // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

ResolveVMInstructions()

static std::shared_ptr< const fml::Mapping > flutter::ResolveVMInstructions ( const Settings &  settings )

static

Definition at line 121 of file dart_snapshot.cc.

                              {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(kDartVmSnapshotInstructions,
                                                0,        // size
                                                nullptr,  // release_func
                                                true      // dontneed_safe
  );
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.vm_snapshot_instr,           // embedder_mapping_callback
      settings.vm_snapshot_instr_path,      // file_path
      settings.application_library_path,    // native_library_path
      DartSnapshot::kVMInstructionsSymbol,  // native_library_symbol_name
      true                                  // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

RunBundleAndSnapshotFromLibrary()

static void flutter::RunBundleAndSnapshotFromLibrary ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jstring  jBundlePath, jstring  jEntrypoint, jstring  jLibraryUrl, jobject  jAssetManager, jobject  jEntrypointArgs  )

static

Definition at line 268 of file platform_view_android_jni_impl.cc.

                                                                     {
  auto apk_asset_provider = std::make_unique<flutter::APKAssetProvider>(
      env,                                            // jni environment
      jAssetManager,                                  // asset manager
      fml::jni::JavaStringToString(env, jBundlePath)  // apk asset dir
  );
  auto entrypoint = fml::jni::JavaStringToString(env, jEntrypoint);
  auto libraryUrl = fml::jni::JavaStringToString(env, jLibraryUrl);
  auto entrypoint_args = fml::jni::StringListToVector(env, jEntrypointArgs);
 
  ANDROID_SHELL_HOLDER->Launch(std::move(apk_asset_provider), entrypoint,
                               libraryUrl, entrypoint_args);
}

RunTester()

int flutter::RunTester	(	const flutter::Settings &	settings,
		bool	run_forever,
		bool	multithreaded
	)

Definition at line 334 of file tester_main.cc.

                                  {
  const auto thread_label = "io.flutter.test.";
 
  // Necessary if we want to use the CPU profiler on the main isolate's mutator
  // thread.
  //
  // OSX WARNING: avoid spawning additional threads before this call due to a
  // kernel bug that may enable SIGPROF on an unintended thread in the process.
  UnblockSIGPROF();
 
  fml::MessageLoop::EnsureInitializedForCurrentThread();
 
  auto current_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
 
  std::unique_ptr<ThreadHost> threadhost;
  fml::RefPtr<fml::TaskRunner> platform_task_runner;
  fml::RefPtr<fml::TaskRunner> raster_task_runner;
  fml::RefPtr<fml::TaskRunner> ui_task_runner;
  fml::RefPtr<fml::TaskRunner> io_task_runner;
 
  if (multithreaded) {
    threadhost = std::make_unique<ThreadHost>(
        thread_label, ThreadHost::Type::kPlatform | ThreadHost::Type::kIo |
                          ThreadHost::Type::kUi | ThreadHost::Type::kRaster);
    platform_task_runner = current_task_runner;
    raster_task_runner = threadhost->raster_thread->GetTaskRunner();
    ui_task_runner = threadhost->ui_thread->GetTaskRunner();
    io_task_runner = threadhost->io_thread->GetTaskRunner();
  } else {
    platform_task_runner = raster_task_runner = ui_task_runner =
        io_task_runner = current_task_runner;
  }
 
  const flutter::TaskRunners task_runners(thread_label,  // dart thread label
                                          platform_task_runner,  // platform
                                          raster_task_runner,    // raster
                                          ui_task_runner,        // ui
                                          io_task_runner         // io
  );
 
  ImpellerVulkanContextHolder impeller_context_holder;
 
#if ALLOW_IMPELLER
  if (settings.enable_impeller) {
    if (!impeller_context_holder.Initialize(
            settings.enable_vulkan_validation)) {
      return EXIT_FAILURE;
    }
  }
#endif  // ALLOW_IMPELLER
 
  Shell::CreateCallback<PlatformView> on_create_platform_view =
      fml::MakeCopyable([impeller_context_holder = std::move(
                             impeller_context_holder)](Shell& shell) mutable {
        return std::make_unique<TesterPlatformView>(
            shell, shell.GetTaskRunners(), std::move(impeller_context_holder));
      });
 
  Shell::CreateCallback<Rasterizer> on_create_rasterizer = [](Shell& shell) {
    return std::make_unique<Rasterizer>(
        shell, Rasterizer::MakeGpuImageBehavior::kBitmap);
  };
 
  g_shell->reset(Shell::Create(flutter::PlatformData(),  //
                               task_runners,             //
                               settings,                 //
                               on_create_platform_view,  //
                               on_create_rasterizer      //
                               )
                     .release());
  auto shell = g_shell->get();
 
  if (!shell || !shell->IsSetup()) {
    FML_LOG(ERROR) << "Could not set up the shell.";
    return EXIT_FAILURE;
  }
 
  if (settings.application_kernel_asset.empty()) {
    FML_LOG(ERROR) << "Dart kernel file not specified.";
    return EXIT_FAILURE;
  }
 
  shell->GetPlatformView()->NotifyCreated();
 
  // Initialize default testing locales. There is no platform to
  // pass locales on the tester, so to retain expected locale behavior,
  // we emulate it in here by passing in 'en_US' and 'zh_CN' as test locales.
  const char* locale_json =
      "{\"method\":\"setLocale\",\"args\":[\"en\",\"US\",\"\",\"\",\"zh\","
      "\"CN\",\"\",\"\"]}";
  auto locale_bytes = fml::MallocMapping::Copy(
      locale_json, locale_json + std::strlen(locale_json));
  fml::RefPtr<flutter::PlatformMessageResponse> response;
  shell->GetPlatformView()->DispatchPlatformMessage(
      std::make_unique<flutter::PlatformMessage>(
          "flutter/localization", std::move(locale_bytes), response));
 
  std::initializer_list<fml::FileMapping::Protection> protection = {
      fml::FileMapping::Protection::kRead};
  auto main_dart_file_mapping = std::make_unique<fml::FileMapping>(
      fml::OpenFile(
          fml::paths::AbsolutePath(settings.application_kernel_asset).c_str(),
          false, fml::FilePermission::kRead),
      protection);
 
  auto isolate_configuration =
      IsolateConfiguration::CreateForKernel(std::move(main_dart_file_mapping));
 
  if (!isolate_configuration) {
    FML_LOG(ERROR) << "Could create isolate configuration.";
    return EXIT_FAILURE;
  }
 
  auto asset_manager = std::make_shared<flutter::AssetManager>();
  asset_manager->PushBack(std::make_unique<flutter::DirectoryAssetBundle>(
      fml::Duplicate(settings.assets_dir), true));
  asset_manager->PushBack(std::make_unique<flutter::DirectoryAssetBundle>(
      fml::OpenDirectory(settings.assets_path.c_str(), false,
                         fml::FilePermission::kRead),
      true));
 
  RunConfiguration run_configuration(std::move(isolate_configuration),
                                     std::move(asset_manager));
 
  // The script completion task observer that will be installed on the UI thread
  // that watched if the engine has any live ports.
  ScriptCompletionTaskObserver completion_observer(
      *shell,  // a valid shell
      fml::MessageLoop::GetCurrent()
          .GetTaskRunner(),  // the message loop to terminate
      run_forever            // should the exit be ignored
  );
 
  bool engine_did_run = false;
 
  fml::AutoResetWaitableEvent latch;
  auto task_observer_add = [&completion_observer]() {
    fml::MessageLoop::GetCurrent().AddTaskObserver(
        reinterpret_cast<intptr_t>(&completion_observer),
        [&completion_observer]() { completion_observer.DidProcessTask(); });
  };
 
  auto task_observer_remove = [&completion_observer, &latch]() {
    fml::MessageLoop::GetCurrent().RemoveTaskObserver(
        reinterpret_cast<intptr_t>(&completion_observer));
    latch.Signal();
  };
 
  shell->RunEngine(std::move(run_configuration),
                   [&engine_did_run, &ui_task_runner,
                    &task_observer_add](Engine::RunStatus run_status) mutable {
                     if (run_status != flutter::Engine::RunStatus::Failure) {
                       engine_did_run = true;
                       // Now that our engine is initialized we can install the
                       // ScriptCompletionTaskObserver
                       fml::TaskRunner::RunNowOrPostTask(ui_task_runner,
                                                         task_observer_add);
                     }
                   });
 
  ConfigureShell(shell);
 
  // Run the message loop and wait for the script to do its thing.
  fml::MessageLoop::GetCurrent().Run();
 
  // Cleanup the completion observer synchronously as it is living on the
  // stack.
  fml::TaskRunner::RunNowOrPostTask(ui_task_runner, task_observer_remove);
  latch.Wait();
 
  delete g_shell->release();
 
  if (!engine_did_run) {
    // If the engine itself didn't have a chance to run, there is no point in
    // asking it if there was an error. Signal a failure unconditionally.
    return EXIT_FAILURE;
  }
 
  return completion_observer.GetExitCodeForLastError();
}

RuntimeStageBackendToString()

static std::string flutter::RuntimeStageBackendToString ( impeller::RuntimeStageBackend  backend )

static

Definition at line 25 of file fragment_program.cc.

                                         {
  switch (backend) {
    case impeller::RuntimeStageBackend::kSkSL:
      return "SkSL";
    case impeller::RuntimeStageBackend::kMetal:
      return "Metal";
    case impeller::RuntimeStageBackend::kOpenGLES:
      return "OpenGLES";
    case impeller::RuntimeStageBackend::kVulkan:
      return "Vulkan";
  }
}

safe_intersection_test()

static bool flutter::safe_intersection_test ( const SkRect *  rect1, const SkRect &  rect2  )

static

Definition at line 122 of file container_layer.cc.

                                                                             {
  if (rect1->isEmpty() || rect2.isEmpty()) {
    return false;
  }
  return rect1->intersects(rect2);
}

SafeNarrow()

static float flutter::SafeNarrow ( double  value )

static

Converts a double to a float, truncating finite values that are larger than FLT_MAX or smaller than FLT_MIN to those values.

Definition at line 15 of file floating_point.h.

                                      {
  if (std::isinf(value) || std::isnan(value)) {
    return static_cast<float>(value);
  } else {
    // Avoid truncation to inf/-inf.
    return std::clamp(static_cast<float>(value),
                      std::numeric_limits<float>::lowest(),
                      std::numeric_limits<float>::max());
  }
}

ScheduleFrame()

static void flutter::ScheduleFrame ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder  )

static

Definition at line 525 of file platform_view_android_jni_impl.cc.

                                                                            {
  ANDROID_SHELL_HOLDER->GetPlatformView()->ScheduleFrame();
}

ScreenshotLayerTreeAsPicture()

static sk_sp< SkData > flutter::ScreenshotLayerTreeAsPicture ( flutter::LayerTree *  tree, flutter::CompositorContext &  compositor_context  )

static

Definition at line 823 of file rasterizer.cc.

                                                  {
#if SLIMPELLER
  return nullptr;
#else  // SLIMPELLER
  FML_DCHECK(tree != nullptr);
  SkPictureRecorder recorder;
  recorder.beginRecording(
      SkRect::MakeWH(tree->frame_size().width(), tree->frame_size().height()));
 
  SkMatrix root_surface_transformation;
  root_surface_transformation.reset();
  DlSkCanvasAdapter canvas(recorder.getRecordingCanvas());
 
  // TODO(amirh): figure out how to take a screenshot with embedded UIView.
  // https://github.com/flutter/flutter/issues/23435
  auto frame = compositor_context.AcquireFrame(nullptr, &canvas, nullptr,
                                               root_surface_transformation,
                                               false, true, nullptr, nullptr);
  frame->Raster(*tree, true, nullptr);
 
#if defined(OS_FUCHSIA)
  SkSerialProcs procs = {0};
  procs.fImageProc = SerializeImageWithoutData;
  procs.fTypefaceProc = SerializeTypefaceWithoutData;
#else
  SkSerialProcs procs = {0};
  procs.fTypefaceProc = SerializeTypefaceWithData;
  procs.fImageProc = [](SkImage* img, void*) -> sk_sp<SkData> {
    return SkPngEncoder::Encode(nullptr, img, SkPngEncoder::Options{});
  };
#endif
 
  return recorder.finishRecordingAsPicture()->serialize(&procs);
#endif  //  SLIMPELLER
}

SearchMapping()

static std::shared_ptr< const fml::Mapping > flutter::SearchMapping ( 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

Definition at line 53 of file dart_snapshot.cc.

                        {
  // Ask the embedder. There is no fallback as we expect the embedders (via
  // their embedding APIs) to just specify the mappings directly.
  if (embedder_mapping_callback) {
    // Note that mapping will be nullptr if the mapping callback returns an
    // invalid mapping. If all the other methods for resolving the data also
    // fail, the engine will stop with accompanying error logs.
    if (auto mapping = embedder_mapping_callback()) {
      return mapping;
    }
  }
 
  // Attempt to open file at path specified.
  if (!file_path.empty()) {
    if (auto file_mapping = GetFileMapping(file_path, is_executable)) {
      return file_mapping;
    }
  }
 
  // Look in application specified native library if specified.
  for (const std::string& path : native_library_path) {
    auto native_library = fml::NativeLibrary::Create(path.c_str());
    auto symbol_mapping = std::make_unique<const fml::SymbolMapping>(
        native_library, native_library_symbol_name);
    if (symbol_mapping->GetMapping() != nullptr) {
      return symbol_mapping;
    }
  }
 
  // Look inside the currently loaded process.
  {
    auto loaded_process = fml::NativeLibrary::CreateForCurrentProcess();
    auto symbol_mapping = std::make_unique<const fml::SymbolMapping>(
        loaded_process, native_library_symbol_name);
    if (symbol_mapping->GetMapping() != nullptr) {
      return symbol_mapping;
    }
  }
 
  return nullptr;
}

SerializeImageWithoutData()

sk_sp< SkData > flutter::SerializeImageWithoutData	(	SkImage *	image,
		void *	ctx
	)

Definition at line 36 of file serialization_callbacks.cc.

                                                                   {
  const auto& info = image->imageInfo();
  SkDynamicMemoryWStream stream;
 
  ImageMetaData metadata = {info.width(), info.height(),
                            static_cast<uint32_t>(info.colorType()),
                            static_cast<uint32_t>(info.alphaType()),
                            static_cast<bool>(info.colorSpace())};
  stream.write(&metadata, sizeof(ImageMetaData));
 
  if (info.colorSpace()) {
    auto color_space_data = info.colorSpace()->serialize();
    FML_CHECK(color_space_data);
    SkMemoryStream color_space_stream(color_space_data);
    stream.writeStream(&color_space_stream, color_space_data->size());
  }
 
  return stream.detachAsData();
};

SerializeLayerSnapshot()

static rapidjson::Value flutter::SerializeLayerSnapshot ( double  device_pixel_ratio, const LayerSnapshotData &  snapshot, rapidjson::Document *  response  )

static

Definition at line 2001 of file shell.cc.

                                 {
  auto& allocator = response->GetAllocator();
  rapidjson::Value result;
  result.SetObject();
  result.AddMember("layer_unique_id", snapshot.GetLayerUniqueId(), allocator);
  result.AddMember("duration_micros", snapshot.GetDuration().ToMicroseconds(),
                   allocator);
 
  const SkRect bounds = snapshot.GetBounds();
  result.AddMember("top", bounds.top(), allocator);
  result.AddMember("left", bounds.left(), allocator);
  result.AddMember("width", bounds.width(), allocator);
  result.AddMember("height", bounds.height(), allocator);
 
  sk_sp<SkData> snapshot_bytes = snapshot.GetSnapshot();
  if (snapshot_bytes) {
    rapidjson::Value image;
    image.SetArray();
    const uint8_t* data =
        reinterpret_cast<const uint8_t*>(snapshot_bytes->data());
    for (size_t i = 0; i < snapshot_bytes->size(); i++) {
      image.PushBack(data[i], allocator);
    }
    result.AddMember("snapshot", image, allocator);
  }
  return result;
}

SerializeTypefaceWithData()

sk_sp< SkData > flutter::SerializeTypefaceWithData	(	SkTypeface *	typeface,
		void *	ctx
	)

Definition at line 18 of file serialization_callbacks.cc.

                                                                         {
  return typeface->serialize(SkTypeface::SerializeBehavior::kDoIncludeData);
}

SerializeTypefaceWithoutData()

sk_sp< SkData > flutter::SerializeTypefaceWithoutData	(	SkTypeface *	typeface,
		void *	ctx
	)

Definition at line 14 of file serialization_callbacks.cc.

                                                                            {
  return SkData::MakeEmpty();
}

ServiceProtocolFailureError()

static void flutter::ServiceProtocolFailureError ( rapidjson::Document *  response, std::string  message  )

static

Definition at line 1716 of file shell.cc.

                                                           {
  auto& allocator = response->GetAllocator();
  response->SetObject();
  const int64_t kJsonServerError = -32000;
  response->AddMember("code", kJsonServerError, allocator);
  response->AddMember("message", std::move(message), allocator);
}

ServiceProtocolParameterError()

static void flutter::ServiceProtocolParameterError ( rapidjson::Document *  response, std::string  error_details  )

static

Definition at line 1702 of file shell.cc.

                                                                   {
  auto& allocator = response->GetAllocator();
  response->SetObject();
  const int64_t kInvalidParams = -32602;
  response->AddMember("code", kInvalidParams, allocator);
  response->AddMember("message", "Invalid params", allocator);
  {
    rapidjson::Value details(rapidjson::kObjectType);
    details.AddMember("details", std::move(error_details), allocator);
    response->AddMember("data", details, allocator);
  }
}

ServiceStreamCancelCallback()

static void flutter::ServiceStreamCancelCallback ( const char *  stream_id )

static

Definition at line 197 of file dart_vm.cc.

                                                               {
  if (strcmp(stream_id, kStdoutStreamId) == 0) {
    dart::bin::SetCaptureStdout(false);
  } else if (strcmp(stream_id, kStderrStreamId) == 0) {
    dart::bin::SetCaptureStderr(false);
  }
}

ServiceStreamListenCallback()

static bool flutter::ServiceStreamListenCallback ( const char *  stream_id )

static

Definition at line 186 of file dart_vm.cc.

                                                               {
  if (strcmp(stream_id, kStdoutStreamId) == 0) {
    dart::bin::SetCaptureStdout(true);
    return true;
  } else if (strcmp(stream_id, kStderrStreamId) == 0) {
    dart::bin::SetCaptureStderr(true);
    return true;
  }
  return false;
}

SetAccessibilityFeatures()

static void flutter::SetAccessibilityFeatures ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jint  flags  )

static

Definition at line 476 of file platform_view_android_jni_impl.cc.

                                                 {
  ANDROID_SHELL_HOLDER->GetPlatformView()->SetAccessibilityFeatures(flags);
}

SetFontFile()

void flutter::SetFontFile

(

const std::string &

file

)

Definition at line 24 of file flow_test_utils.cc.

                                        {
  gFontFile = file;
}

SetGoldenDir()

void flutter::SetGoldenDir

(

const std::string &

dir

)

Definition at line 16 of file flow_test_utils.cc.

                                        {
  gGoldenDir = dir;
}

SetSemanticsEnabled()

static void flutter::SetSemanticsEnabled ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jboolean  enabled  )

static

Definition at line 469 of file platform_view_android_jni_impl.cc.

                                                  {
  ANDROID_SHELL_HOLDER->GetPlatformView()->SetSemanticsEnabled(enabled);
}

SettingsFromCommandLine()

Settings flutter::SettingsFromCommandLine

(

const fml::CommandLine &

command_line

)

Definition at line 228 of file switches.cc.

                                                                     {
  Settings settings = {};
 
  // Set executable name.
  if (command_line.has_argv0()) {
    settings.executable_name = command_line.argv0();
  }
 
  // Enable the VM Service
  settings.enable_vm_service =
      !command_line.HasOption(FlagForSwitch(Switch::DisableVMService)) &&
      // TODO(bkonyi): remove once flutter_tools no longer uses this option.
      // See https://github.com/dart-lang/sdk/issues/50233
      !command_line.HasOption(FlagForSwitch(Switch::DisableObservatory));
 
  // Enable mDNS VM Service Publication
  settings.enable_vm_service_publication =
      !command_line.HasOption(
          FlagForSwitch(Switch::DisableVMServicePublication)) &&
      !command_line.HasOption(
          FlagForSwitch(Switch::DisableObservatoryPublication));
 
  // Set VM Service Host
  if (command_line.HasOption(FlagForSwitch(Switch::DeviceVMServiceHost))) {
    command_line.GetOptionValue(FlagForSwitch(Switch::DeviceVMServiceHost),
                                &settings.vm_service_host);
  } else if (command_line.HasOption(
                 FlagForSwitch(Switch::DeviceObservatoryHost))) {
    // TODO(bkonyi): remove once flutter_tools no longer uses this option.
    // See https://github.com/dart-lang/sdk/issues/50233
    command_line.GetOptionValue(FlagForSwitch(Switch::DeviceObservatoryHost),
                                &settings.vm_service_host);
  }
  // Default the VM Service port based on --ipv6 if not set.
  if (settings.vm_service_host.empty()) {
    settings.vm_service_host =
        command_line.HasOption(FlagForSwitch(Switch::IPv6)) ? "::1"
                                                            : "127.0.0.1";
  }
 
  // Set VM Service Port
  if (command_line.HasOption(FlagForSwitch(Switch::DeviceVMServicePort))) {
    if (!GetSwitchValue(command_line, Switch::DeviceVMServicePort,
                        &settings.vm_service_port)) {
      FML_LOG(INFO)
          << "VM Service port specified was malformed. Will default to "
          << settings.vm_service_port;
    }
  } else if (command_line.HasOption(
                 FlagForSwitch(Switch::DeviceObservatoryPort))) {
    // TODO(bkonyi): remove once flutter_tools no longer uses this option.
    // See https://github.com/dart-lang/sdk/issues/50233
    if (!GetSwitchValue(command_line, Switch::DeviceObservatoryPort,
                        &settings.vm_service_port)) {
      FML_LOG(INFO)
          << "VM Service port specified was malformed. Will default to "
          << settings.vm_service_port;
    }
  }
 
  settings.may_insecurely_connect_to_all_domains = !command_line.HasOption(
      FlagForSwitch(Switch::DisallowInsecureConnections));
 
  command_line.GetOptionValue(FlagForSwitch(Switch::DomainNetworkPolicy),
                              &settings.domain_network_policy);
 
  // Disable need for authentication codes for VM service communication, if
  // specified.
  settings.disable_service_auth_codes =
      command_line.HasOption(FlagForSwitch(Switch::DisableServiceAuthCodes));
 
  // Allow fallback to automatic port selection if binding to a specified port
  // fails.
  settings.enable_service_port_fallback =
      command_line.HasOption(FlagForSwitch(Switch::EnableServicePortFallback));
 
  // Checked mode overrides.
  settings.disable_dart_asserts =
      command_line.HasOption(FlagForSwitch(Switch::DisableDartAsserts));
 
  settings.start_paused =
      command_line.HasOption(FlagForSwitch(Switch::StartPaused));
 
  settings.enable_checked_mode =
      command_line.HasOption(FlagForSwitch(Switch::EnableCheckedMode));
 
  settings.enable_dart_profiling =
      command_line.HasOption(FlagForSwitch(Switch::EnableDartProfiling));
 
  settings.enable_software_rendering =
      command_line.HasOption(FlagForSwitch(Switch::EnableSoftwareRendering));
 
  settings.endless_trace_buffer =
      command_line.HasOption(FlagForSwitch(Switch::EndlessTraceBuffer));
 
  settings.trace_startup =
      command_line.HasOption(FlagForSwitch(Switch::TraceStartup));
 
  settings.enable_serial_gc =
      command_line.HasOption(FlagForSwitch(Switch::EnableSerialGC));
 
#if !FLUTTER_RELEASE
  settings.trace_skia = true;
 
  if (command_line.HasOption(FlagForSwitch(Switch::TraceSkia))) {
    // If --trace-skia is specified, then log all Skia events.
    settings.trace_skia_allowlist.reset();
  } else {
    std::string trace_skia_allowlist;
    command_line.GetOptionValue(FlagForSwitch(Switch::TraceSkiaAllowlist),
                                &trace_skia_allowlist);
    if (trace_skia_allowlist.size()) {
      settings.trace_skia_allowlist = ParseCommaDelimited(trace_skia_allowlist);
    } else {
      settings.trace_skia_allowlist = {"skia.shaders"};
    }
  }
#endif  // !FLUTTER_RELEASE
 
  std::string trace_allowlist;
  command_line.GetOptionValue(FlagForSwitch(Switch::TraceAllowlist),
                              &trace_allowlist);
  settings.trace_allowlist = ParseCommaDelimited(trace_allowlist);
 
  settings.trace_systrace =
      command_line.HasOption(FlagForSwitch(Switch::TraceSystrace));
 
  command_line.GetOptionValue(FlagForSwitch(Switch::TraceToFile),
                              &settings.trace_to_file);
 
  settings.skia_deterministic_rendering_on_cpu =
      command_line.HasOption(FlagForSwitch(Switch::SkiaDeterministicRendering));
 
  settings.verbose_logging =
      command_line.HasOption(FlagForSwitch(Switch::VerboseLogging));
 
  command_line.GetOptionValue(FlagForSwitch(Switch::FlutterAssetsDir),
                              &settings.assets_path);
 
  std::vector<std::string_view> aot_shared_library_name =
      command_line.GetOptionValues(FlagForSwitch(Switch::AotSharedLibraryName));
 
  std::vector<std::string_view> vmservice_shared_library_name =
      command_line.GetOptionValues(
          FlagForSwitch(Switch::AotVMServiceSharedLibraryName));
  for (auto path : vmservice_shared_library_name) {
    settings.vmservice_snapshot_library_path.emplace_back(path);
  }
 
  std::string snapshot_asset_path;
  command_line.GetOptionValue(FlagForSwitch(Switch::SnapshotAssetPath),
                              &snapshot_asset_path);
 
  std::string vm_snapshot_data_filename;
  command_line.GetOptionValue(FlagForSwitch(Switch::VmSnapshotData),
                              &vm_snapshot_data_filename);
 
  command_line.GetOptionValue(FlagForSwitch(Switch::Route), &settings.route);
 
  std::string vm_snapshot_instr_filename;
  command_line.GetOptionValue(FlagForSwitch(Switch::VmSnapshotInstructions),
                              &vm_snapshot_instr_filename);
 
  std::string isolate_snapshot_data_filename;
  command_line.GetOptionValue(FlagForSwitch(Switch::IsolateSnapshotData),
                              &isolate_snapshot_data_filename);
 
  std::string isolate_snapshot_instr_filename;
  command_line.GetOptionValue(
      FlagForSwitch(Switch::IsolateSnapshotInstructions),
      &isolate_snapshot_instr_filename);
 
  if (!aot_shared_library_name.empty()) {
    for (std::string_view name : aot_shared_library_name) {
      settings.application_library_path.emplace_back(name);
    }
  } else if (!snapshot_asset_path.empty()) {
    settings.vm_snapshot_data_path =
        fml::paths::JoinPaths({snapshot_asset_path, vm_snapshot_data_filename});
    settings.vm_snapshot_instr_path = fml::paths::JoinPaths(
        {snapshot_asset_path, vm_snapshot_instr_filename});
    settings.isolate_snapshot_data_path = fml::paths::JoinPaths(
        {snapshot_asset_path, isolate_snapshot_data_filename});
    settings.isolate_snapshot_instr_path = fml::paths::JoinPaths(
        {snapshot_asset_path, isolate_snapshot_instr_filename});
  }
 
  command_line.GetOptionValue(FlagForSwitch(Switch::CacheDirPath),
                              &settings.temp_directory_path);
 
  bool leak_vm = "true" == command_line.GetOptionValueWithDefault(
                               FlagForSwitch(Switch::LeakVM), "true");
  settings.leak_vm = leak_vm;
 
  if (settings.icu_initialization_required) {
    command_line.GetOptionValue(FlagForSwitch(Switch::ICUDataFilePath),
                                &settings.icu_data_path);
    if (command_line.HasOption(FlagForSwitch(Switch::ICUSymbolPrefix))) {
      std::string icu_symbol_prefix, native_lib_path;
      command_line.GetOptionValue(FlagForSwitch(Switch::ICUSymbolPrefix),
                                  &icu_symbol_prefix);
      command_line.GetOptionValue(FlagForSwitch(Switch::ICUNativeLibPath),
                                  &native_lib_path);
 
#if FML_OS_ANDROID
      settings.icu_mapper = GetICUStaticMapping;
#else
      settings.icu_mapper = [icu_symbol_prefix, native_lib_path] {
        return GetSymbolMapping(icu_symbol_prefix, native_lib_path);
      };
#endif
    }
  }
 
  settings.use_test_fonts =
      command_line.HasOption(FlagForSwitch(Switch::UseTestFonts));
  settings.use_asset_fonts =
      !command_line.HasOption(FlagForSwitch(Switch::DisableAssetFonts));
 
  {
    std::string enable_impeller_value;
    if (command_line.GetOptionValue(FlagForSwitch(Switch::EnableImpeller),
                                    &enable_impeller_value)) {
      settings.enable_impeller =
          enable_impeller_value.empty() || "true" == enable_impeller_value;
    }
  }
 
  {
    std::string impeller_backend_value;
    if (command_line.GetOptionValue(FlagForSwitch(Switch::ImpellerBackend),
                                    &impeller_backend_value)) {
      if (!impeller_backend_value.empty()) {
        settings.requested_rendering_backend = impeller_backend_value;
      }
    }
  }
 
  settings.enable_vulkan_validation =
      command_line.HasOption(FlagForSwitch(Switch::EnableVulkanValidation));
  settings.enable_opengl_gpu_tracing =
      command_line.HasOption(FlagForSwitch(Switch::EnableOpenGLGPUTracing));
  settings.enable_vulkan_gpu_tracing =
      command_line.HasOption(FlagForSwitch(Switch::EnableVulkanGPUTracing));
 
  settings.enable_embedder_api =
      command_line.HasOption(FlagForSwitch(Switch::EnableEmbedderAPI));
 
  settings.prefetched_default_font_manager = command_line.HasOption(
      FlagForSwitch(Switch::PrefetchedDefaultFontManager));
 
  std::string all_dart_flags;
  if (command_line.GetOptionValue(FlagForSwitch(Switch::DartFlags),
                                  &all_dart_flags)) {
    // Assume that individual flags are comma separated.
    std::vector<std::string> flags = ParseCommaDelimited(all_dart_flags);
    for (const auto& flag : flags) {
      if (!IsAllowedDartVMFlag(flag)) {
        FML_LOG(FATAL) << "Encountered disallowed Dart VM flag: " << flag;
      }
      settings.dart_flags.push_back(flag);
    }
  }
 
#if !FLUTTER_RELEASE
  command_line.GetOptionValue(FlagForSwitch(Switch::LogTag), &settings.log_tag);
#endif
 
  settings.dump_skp_on_shader_compilation =
      command_line.HasOption(FlagForSwitch(Switch::DumpSkpOnShaderCompilation));
 
  settings.cache_sksl =
      command_line.HasOption(FlagForSwitch(Switch::CacheSkSL));
 
  settings.purge_persistent_cache =
      command_line.HasOption(FlagForSwitch(Switch::PurgePersistentCache));
 
  if (command_line.HasOption(FlagForSwitch(Switch::OldGenHeapSize))) {
    std::string old_gen_heap_size;
    command_line.GetOptionValue(FlagForSwitch(Switch::OldGenHeapSize),
                                &old_gen_heap_size);
    settings.old_gen_heap_size = std::stoi(old_gen_heap_size);
  }
 
  if (command_line.HasOption(
          FlagForSwitch(Switch::ResourceCacheMaxBytesThreshold))) {
    std::string resource_cache_max_bytes_threshold;
    command_line.GetOptionValue(
        FlagForSwitch(Switch::ResourceCacheMaxBytesThreshold),
        &resource_cache_max_bytes_threshold);
    settings.resource_cache_max_bytes_threshold =
        std::stoi(resource_cache_max_bytes_threshold);
  }
 
  settings.enable_platform_isolates =
      command_line.HasOption(FlagForSwitch(Switch::EnablePlatformIsolates));
 
  return settings;
}

SetViewportMetrics()

static void flutter::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

Definition at line 300 of file platform_view_android_jni_impl.cc.

                                                                   {
  // Convert java->c++. javaDisplayFeaturesBounds, javaDisplayFeaturesType and
  // javaDisplayFeaturesState cannot be null
  jsize rectSize = env->GetArrayLength(javaDisplayFeaturesBounds);
  std::vector<int> boundsIntVector(rectSize);
  env->GetIntArrayRegion(javaDisplayFeaturesBounds, 0, rectSize,
                         &boundsIntVector[0]);
  std::vector<double> displayFeaturesBounds(boundsIntVector.begin(),
                                            boundsIntVector.end());
  jsize typeSize = env->GetArrayLength(javaDisplayFeaturesType);
  std::vector<int> displayFeaturesType(typeSize);
  env->GetIntArrayRegion(javaDisplayFeaturesType, 0, typeSize,
                         &displayFeaturesType[0]);
 
  jsize stateSize = env->GetArrayLength(javaDisplayFeaturesState);
  std::vector<int> displayFeaturesState(stateSize);
  env->GetIntArrayRegion(javaDisplayFeaturesState, 0, stateSize,
                         &displayFeaturesState[0]);
 
  const flutter::ViewportMetrics metrics{
      static_cast<double>(devicePixelRatio),
      static_cast<double>(physicalWidth),
      static_cast<double>(physicalHeight),
      static_cast<double>(physicalPaddingTop),
      static_cast<double>(physicalPaddingRight),
      static_cast<double>(physicalPaddingBottom),
      static_cast<double>(physicalPaddingLeft),
      static_cast<double>(physicalViewInsetTop),
      static_cast<double>(physicalViewInsetRight),
      static_cast<double>(physicalViewInsetBottom),
      static_cast<double>(physicalViewInsetLeft),
      static_cast<double>(systemGestureInsetTop),
      static_cast<double>(systemGestureInsetRight),
      static_cast<double>(systemGestureInsetBottom),
      static_cast<double>(systemGestureInsetLeft),
      static_cast<double>(physicalTouchSlop),
      displayFeaturesBounds,
      displayFeaturesType,
      displayFeaturesState,
      0,  // Display ID
  };
 
  ANDROID_SHELL_HOLDER->GetPlatformView()->SetViewportMetrics(
      kFlutterImplicitViewId, metrics);
}

ShouldUseMetalRenderer()

bool flutter::ShouldUseMetalRenderer

(

)

Definition at line 22 of file rendering_api_selection.mm.

                              {
  bool ios_version_supports_metal = false;
  if (@available(iOS METAL_IOS_VERSION_BASELINE, *)) {
    id<MTLDevice> device = MTLCreateSystemDefaultDevice();
    ios_version_supports_metal = [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily1_v3];
  }
  return ios_version_supports_metal;
}

Spawn()

EXPORTED void flutter::Spawn	(	const char *	entrypoint,
		const char *	route
	)

Definition at line 544 of file tester_main.cc.

                                                               {
  auto shell = g_shell->get();
  auto isolate = Dart_CurrentIsolate();
  auto spawn_task = [shell, entrypoint = std::string(entrypoint),
                     route = std::string(route)]() {
    auto configuration = RunConfiguration::InferFromSettings(
        shell->GetSettings(), /*io_worker=*/nullptr,
        /*launch_type=*/IsolateLaunchType::kExistingGroup);
    configuration.SetEntrypoint(entrypoint);
 
    Shell::CreateCallback<PlatformView> on_create_platform_view =
        fml::MakeCopyable([](Shell& shell) mutable {
          ImpellerVulkanContextHolder impeller_context_holder;
          return std::make_unique<TesterPlatformView>(
              shell, shell.GetTaskRunners(),
              std::move(impeller_context_holder));
        });
 
    Shell::CreateCallback<Rasterizer> on_create_rasterizer = [](Shell& shell) {
      return std::make_unique<Rasterizer>(
          shell, Rasterizer::MakeGpuImageBehavior::kBitmap);
    };
 
    // Spawn a shell, and keep it running until it has no live ports, then
    // delete it on the platform thread.
    auto spawned_shell =
        shell
            ->Spawn(std::move(configuration), route, on_create_platform_view,
                    on_create_rasterizer)
            .release();
 
    ConfigureShell(spawned_shell);
 
    fml::TaskRunner::RunNowOrPostTask(
        spawned_shell->GetTaskRunners().GetUITaskRunner(), [spawned_shell]() {
          fml::MessageLoop::GetCurrent().AddTaskObserver(
              reinterpret_cast<intptr_t>(spawned_shell), [spawned_shell]() {
                if (spawned_shell->EngineHasLivePorts()) {
                  return;
                }
 
                fml::MessageLoop::GetCurrent().RemoveTaskObserver(
                    reinterpret_cast<intptr_t>(spawned_shell));
                // Shell must be deleted on the platform task runner.
                fml::TaskRunner::RunNowOrPostTask(
                    spawned_shell->GetTaskRunners().GetPlatformTaskRunner(),
                    [spawned_shell]() { delete spawned_shell; });
              });
        });
  };
  Dart_ExitIsolate();
  // The global shell pointer is never deleted, short of application exit.
  // This UI task runner cannot be latched because it will block spawning a new
  // shell in the case where flutter_tester is running multithreaded.
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), spawn_task);
 
  Dart_EnterIsolate(isolate);
}

SpawnJNI()

static jobject flutter::SpawnJNI ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jstring  jEntrypoint, jstring  jLibraryUrl, jstring  jInitialRoute, jobject  jEntrypointArgs  )

static

Definition at line 185 of file platform_view_android_jni_impl.cc.

                                                 {
  jobject jni = env->NewObject(g_flutter_jni_class->obj(), g_jni_constructor);
  if (jni == nullptr) {
    FML_LOG(ERROR) << "Could not create a FlutterJNI instance";
    return nullptr;
  }
 
  fml::jni::JavaObjectWeakGlobalRef java_jni(env, jni);
  std::shared_ptr<PlatformViewAndroidJNI> jni_facade =
      std::make_shared<PlatformViewAndroidJNIImpl>(java_jni);
 
  auto entrypoint = fml::jni::JavaStringToString(env, jEntrypoint);
  auto libraryUrl = fml::jni::JavaStringToString(env, jLibraryUrl);
  auto initial_route = fml::jni::JavaStringToString(env, jInitialRoute);
  auto entrypoint_args = fml::jni::StringListToVector(env, jEntrypointArgs);
 
  auto spawned_shell_holder = ANDROID_SHELL_HOLDER->Spawn(
      jni_facade, entrypoint, libraryUrl, initial_route, entrypoint_args);
 
  if (spawned_shell_holder == nullptr || !spawned_shell_holder->IsValid()) {
    FML_LOG(ERROR) << "Could not spawn Shell";
    return nullptr;
  }
 
  jobject javaLong = env->CallStaticObjectMethod(
      g_java_long_class->obj(), g_long_constructor,
      reinterpret_cast<jlong>(spawned_shell_holder.release()));
  if (javaLong == nullptr) {
    FML_LOG(ERROR) << "Could not create a Long instance";
    return nullptr;
  }
 
  env->SetObjectField(jni, g_jni_shell_holder_field, javaLong);
 
  return jni;
}

StartTestSuite()

static void flutter::StartTestSuite ( const impeller::android::NativeWindow &  window )

static

Definition at line 18 of file gtest_activity.cc.

                                                                      {
  auto timeout_listener = new flutter::testing::TestTimeoutListener(
      fml::TimeDelta::FromSeconds(120u));
  auto logger_listener = new flutter::testing::LoggerListener();
 
  auto& listeners = ::testing::UnitTest::GetInstance()->listeners();
 
  listeners.Append(timeout_listener);
  listeners.Append(logger_listener);
 
  int result = RUN_ALL_TESTS();
 
  delete listeners.Release(timeout_listener);
  delete listeners.Release(logger_listener);
 
  FML_CHECK(result == 0);
}

StartupAndShutdownShell()

static void flutter::StartupAndShutdownShell ( benchmark::State &  state, bool  measure_startup, bool  measure_shutdown  )

static

Definition at line 16 of file shell_benchmarks.cc.

                                                           {
  auto assets_dir = fml::OpenDirectory(testing::GetFixturesPath(), false,
                                       fml::FilePermission::kRead);
  std::unique_ptr<Shell> shell;
  std::unique_ptr<ThreadHost> thread_host;
  testing::ELFAOTSymbols aot_symbols;
 
  {
    benchmarking::ScopedPauseTiming pause(state, !measure_startup);
    Settings settings = {};
    settings.task_observer_add = [](intptr_t, const fml::closure&) {};
    settings.task_observer_remove = [](intptr_t) {};
 
    if (DartVM::IsRunningPrecompiledCode()) {
      aot_symbols = testing::LoadELFSymbolFromFixturesIfNeccessary(
          testing::kDefaultAOTAppELFFileName);
      FML_CHECK(
          testing::PrepareSettingsForAOTWithSymbols(settings, aot_symbols))
          << "Could not set up settings with AOT symbols.";
    } else {
      settings.application_kernels = [&]() {
        std::vector<std::unique_ptr<const fml::Mapping>> kernel_mappings;
        kernel_mappings.emplace_back(
            fml::FileMapping::CreateReadOnly(assets_dir, "kernel_blob.bin"));
        return kernel_mappings;
      };
    }
 
    thread_host = std::make_unique<ThreadHost>(ThreadHost::ThreadHostConfig(
        "io.flutter.bench.",
        ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
            ThreadHost::Type::kIo | ThreadHost::Type::kUi));
 
    TaskRunners task_runners("test",
                             thread_host->platform_thread->GetTaskRunner(),
                             thread_host->raster_thread->GetTaskRunner(),
                             thread_host->ui_thread->GetTaskRunner(),
                             thread_host->io_thread->GetTaskRunner());
 
    shell = Shell::Create(
        flutter::PlatformData(), task_runners, settings,
        [](Shell& shell) {
          return std::make_unique<PlatformView>(shell, shell.GetTaskRunners());
        },
        [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
  }
 
  FML_CHECK(shell);
 
  {
    // The ui thread could be busy processing tasks after shell created, e.g.,
    // default font manager setup. The measurement of shell shutdown should be
    // considered after those ui tasks have been done.
    //
    // However, if we're measuring the complete time from startup to shutdown,
    // this time should still be included.
    benchmarking::ScopedPauseTiming pause(
        state, !measure_shutdown || !measure_startup);
    fml::AutoResetWaitableEvent latch;
    fml::TaskRunner::RunNowOrPostTask(thread_host->ui_thread->GetTaskRunner(),
                                      [&latch]() { latch.Signal(); });
    latch.Wait();
  }
 
  {
    benchmarking::ScopedPauseTiming pause(state, !measure_shutdown);
    // Shutdown must occur synchronously on the platform thread.
    fml::AutoResetWaitableEvent latch;
    fml::TaskRunner::RunNowOrPostTask(
        thread_host->platform_thread->GetTaskRunner(),
        [&shell, &latch]() mutable {
          shell.reset();
          latch.Signal();
        });
    latch.Wait();
    thread_host.reset();
  }
 
  FML_CHECK(!shell);
}

store_points()

static void flutter::store_points ( char *  dst, int  offset, const float *  src, int  count  )

static

Definition at line 218 of file dl_vertices.cc.

                                                                             {
  SkPoint* points = reinterpret_cast<SkPoint*>(dst + offset);
  for (int i = 0; i < count; i++) {
    points[i] = SkPoint::Make(src[i * 2], src[i * 2 + 1]);
  }
}

StringToAppExitType()

static AppExitType flutter::StringToAppExitType ( const std::string &  string )

static

Definition at line 212 of file platform_handler.cc.

                                                                {
  if (string.compare(PlatformHandler::kExitTypeRequired) == 0) {
    return AppExitType::required;
  } else if (string.compare(PlatformHandler::kExitTypeCancelable) == 0) {
    return AppExitType::cancelable;
  }
  FML_LOG(ERROR) << string << " is not recognized as a valid exit type.";
  return AppExitType::required;
}

SurfaceChanged()

static void flutter::SurfaceChanged ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jint  width, jint  height  )

static

Definition at line 255 of file platform_view_android_jni_impl.cc.

                                        {
  ANDROID_SHELL_HOLDER->GetPlatformView()->NotifyChanged(
      SkISize::Make(width, height));
}

SurfaceCreated()

static void flutter::SurfaceCreated ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jobject  jsurface  )

static

Definition at line 228 of file platform_view_android_jni_impl.cc.

                                             {
  // Note: This frame ensures that any local references used by
  // ANativeWindow_fromSurface are released immediately. This is needed as a
  // workaround for https://code.google.com/p/android/issues/detail?id=68174
  fml::jni::ScopedJavaLocalFrame scoped_local_reference_frame(env);
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(
      ANativeWindow_fromSurface(env, jsurface));
  ANDROID_SHELL_HOLDER->GetPlatformView()->NotifyCreated(std::move(window));
}

SurfaceDestroyed()

static void flutter::SurfaceDestroyed ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder  )

static

Definition at line 264 of file platform_view_android_jni_impl.cc.

                                                                               {
  ANDROID_SHELL_HOLDER->GetPlatformView()->NotifyDestroyed();
}

SurfaceWindowChanged()

static void flutter::SurfaceWindowChanged ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jobject  jsurface  )

static

Definition at line 241 of file platform_view_android_jni_impl.cc.

                                                   {
  // Note: This frame ensures that any local references used by
  // ANativeWindow_fromSurface are released immediately. This is needed as a
  // workaround for https://code.google.com/p/android/issues/detail?id=68174
  fml::jni::ScopedJavaLocalFrame scoped_local_reference_frame(env);
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(
      ANativeWindow_fromSurface(env, jsurface));
  ANDROID_SHELL_HOLDER->GetPlatformView()->NotifySurfaceWindowChanged(
      std::move(window));
}

TeardownContext()

static bool flutter::TeardownContext ( EGLDisplay  display, EGLContext  context  )

static

Definition at line 55 of file android_context_gl_skia.cc.

                                                                    {
  if (context != EGL_NO_CONTEXT) {
    return eglDestroyContext(display, context) == EGL_TRUE;
  }
 
  return true;
}

TemplaterMain()

bool flutter::TemplaterMain

(

const fml::CommandLine &

command_line

)

Definition at line 19 of file templater_main.cc.

                                                       {
  std::string input_path;
  std::string output_path;
 
  if (!command_line.GetOptionValue("templater-input", &input_path)) {
    FML_LOG(ERROR)
        << "Input template path not specified. Use --templater-input.";
    return false;
  }
  if (!command_line.GetOptionValue("templater-output", &output_path)) {
    FML_LOG(ERROR)
        << "Input template path not specified. Use --templater-output.";
    return false;
  }
 
  auto input = fml::FileMapping::CreateReadOnly(input_path);
  if (!input) {
    FML_LOG(ERROR) << "Could not open input file: " << input_path;
    return false;
  }
 
  nlohmann::json arguments;
  for (const auto& option : command_line.options()) {
    arguments[option.name] = option.value;
  }
  inja::Environment env;
  auto rendered_template = env.render(
      std::string_view{reinterpret_cast<const char*>(input->GetMapping()),
                       input->GetSize()},
      arguments);
  auto output = fml::NonOwnedMapping{
      reinterpret_cast<const uint8_t*>(rendered_template.data()),
      rendered_template.size()};
 
  auto current_dir =
      fml::OpenDirectory(std::filesystem::current_path().u8string().c_str(),
                         false, fml::FilePermission::kReadWrite);
  if (!current_dir.is_valid()) {
    FML_LOG(ERROR) << "Could not open current directory.";
    return false;
  }
  if (!fml::WriteAtomically(current_dir, output_path.c_str(), output)) {
    FML_LOG(ERROR) << "Could not write output to path: " << output_path;
    return false;
  }
  return true;
}

TEST() [1/363]

flutter::TEST	(	BasicMessageChannelTest	,
		Registration
	)

Definition at line 58 of file basic_message_channel_unittests.cc.

                                            {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMessageCodec& codec = StandardMessageCodec::GetInstance();
  BasicMessageChannel channel(&messenger, channel_name, &codec);
 
  bool callback_called = false;
  const std::string message_value("hello");
  channel.SetMessageHandler(
      [&callback_called, message_value](const auto& message, auto reply) {
        callback_called = true;
        // Ensure that the wrapper received a correctly decoded message and a
        // reply.
        EXPECT_EQ(std::get<std::string>(message), message_value);
        EXPECT_NE(reply, nullptr);
      });
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
  // Send a test message to trigger the handler test assertions.
  auto message = codec.EncodeMessage(EncodableValue(message_value));
 
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
  EXPECT_EQ(callback_called, true);
}

TEST() [2/363]

flutter::TEST	(	BasicMessageChannelTest	,
		Resize
	)

Definition at line 103 of file basic_message_channel_unittests.cc.

                                      {
  TestBinaryMessenger messenger;
  const std::string channel_name("flutter/test");
  BasicMessageChannel channel(&messenger, channel_name,
                              &flutter::StandardMessageCodec::GetInstance());
 
  channel.Resize(3);
 
  // Because the Dart implementation for the control channel implements its own
  // custom deserialization logic, this test compares the generated bytes array
  // to the expected one (for instance, the deserialization logic expects the
  // size parameter of the resize method call to be an uint32).
  //
  // The expected content was created from the following Dart code:
  //   MethodCall call = MethodCall('resize', ['flutter/test',3]);
  //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
  const int expected_message_size = 29;
 
  EXPECT_EQ(messenger.send_called(), true);
  EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
            expected_message_size);
 
  int expected[expected_message_size] = {
      7,   6,   114, 101, 115, 105, 122, 101, 12,  2, 7, 12, 102, 108, 117,
      116, 116, 101, 114, 47,  116, 101, 115, 116, 3, 3, 0,  0,   0};
  for (int i = 0; i < expected_message_size; i++) {
    EXPECT_EQ(messenger.last_message()[i], expected[i]);
  }
}

TEST() [3/363]

flutter::TEST	(	BasicMessageChannelTest	,
		SetWarnsOnOverflow
	)

Definition at line 135 of file basic_message_channel_unittests.cc.

                                                  {
  TestBinaryMessenger messenger;
 
  const std::string channel_name("flutter/test");
  BasicMessageChannel channel(&messenger, channel_name,
                              &flutter::StandardMessageCodec::GetInstance());
 
  channel.SetWarnsOnOverflow(false);
 
  // Because the Dart implementation for the control channel implements its own
  // custom deserialization logic, this test compares the generated bytes array
  // to the expected one.
  //
  // The expected content was created from the following Dart code:
  //   MethodCall call = MethodCall('overflow',['flutter/test', true]);
  //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
  const int expected_message_size = 27;
 
  EXPECT_EQ(messenger.send_called(), true);
  EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
            expected_message_size);
 
  int expected[expected_message_size] = {
      7,   8,   111, 118, 101, 114, 102, 108, 111, 119, 12,  2,   7, 12,
      102, 108, 117, 116, 116, 101, 114, 47,  116, 101, 115, 116, 1};
  for (int i = 0; i < expected_message_size; i++) {
    EXPECT_EQ(messenger.last_message()[i], expected[i]);
  }
}

TEST() [4/363]

flutter::TEST	(	BasicMessageChannelTest	,
		Unregistration
	)

Definition at line 86 of file basic_message_channel_unittests.cc.

                                              {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  BasicMessageChannel channel(&messenger, channel_name,
                              &flutter::StandardMessageCodec::GetInstance());
 
  channel.SetMessageHandler([](const auto& message, auto reply) {});
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  channel.SetMessageHandler(nullptr);
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_EQ(messenger.last_message_handler(), nullptr);
}

TEST() [5/363]

flutter::TEST	(	DartServiceIsolateTest	,
		CanAddAndRemoveHandles
	)

Definition at line 11 of file dart_service_isolate_unittests.cc.

                                                     {
  ASSERT_EQ(DartServiceIsolate::AddServerStatusCallback(nullptr), 0);
  auto handle = DartServiceIsolate::AddServerStatusCallback([](const auto&) {});
  ASSERT_NE(handle, 0);
  ASSERT_TRUE(DartServiceIsolate::RemoveServerStatusCallback(handle));
}

TEST() [6/363]

flutter::TEST	(	EncodableValueTest	,
		Bool
	)

Definition at line 18 of file encodable_value_unittests.cc.

                               {
  EncodableValue value(false);
 
  EXPECT_FALSE(std::get<bool>(value));
  value = true;
  EXPECT_TRUE(std::get<bool>(value));
}

TEST() [7/363]

flutter::TEST	(	EncodableValueTest	,
		Comparison
	)

Definition at line 177 of file encodable_value_unittests.cc.

                                     {
  EncodableList values = {
      // Null
      EncodableValue(),
      // Bool
      EncodableValue(true),
      EncodableValue(false),
      // Int
      EncodableValue(-7),
      EncodableValue(0),
      EncodableValue(100),
      // Long
      EncodableValue(INT64_C(-7)),
      EncodableValue(INT64_C(0)),
      EncodableValue(INT64_C(100)),
      // Double
      EncodableValue(-7.0),
      EncodableValue(0.0),
      EncodableValue(100.0),
      // String
      EncodableValue("one"),
      EncodableValue("two"),
      // ByteList
      EncodableValue(std::vector<uint8_t>{0, 1}),
      EncodableValue(std::vector<uint8_t>{0, 10}),
      // IntList
      EncodableValue(std::vector<int32_t>{0, 1}),
      EncodableValue(std::vector<int32_t>{0, 100}),
      // LongList
      EncodableValue(std::vector<int64_t>{0, INT64_C(1)}),
      EncodableValue(std::vector<int64_t>{0, INT64_C(100)}),
      // DoubleList
      EncodableValue(std::vector<double>{0, INT64_C(1)}),
      EncodableValue(std::vector<double>{0, INT64_C(100)}),
      // List
      EncodableValue(EncodableList{EncodableValue(), EncodableValue(true)}),
      EncodableValue(EncodableList{EncodableValue(), EncodableValue(1.0)}),
      // Map
      EncodableValue(EncodableMap{{EncodableValue(), EncodableValue(true)},
                                  {EncodableValue(7), EncodableValue(7.0)}}),
      EncodableValue(
          EncodableMap{{EncodableValue(), EncodableValue(1.0)},
                       {EncodableValue("key"), EncodableValue("value")}}),
      // FloatList
      EncodableValue(std::vector<float>{0, 1}),
      EncodableValue(std::vector<float>{0, 100}),
  };
 
  for (size_t i = 0; i < values.size(); ++i) {
    const auto& a = values[i];
    for (size_t j = 0; j < values.size(); ++j) {
      const auto& b = values[j];
      if (i == j) {
        // Identical objects should always be equal.
        EXPECT_FALSE(a < b);
        EXPECT_FALSE(b < a);
      } else {
        // All other comparisons should be consistent, but the direction doesn't
        // matter.
        EXPECT_NE(a < b, b < a) << "Indexes: " << i << ", " << j;
      }
    }
 
    // Copies should always be equal.
    EncodableValue copy(a);
    EXPECT_FALSE(a < copy || copy < a);
  }
}

TEST() [8/363]

flutter::TEST	(	EncodableValueTest	,
		CString
	)

Definition at line 68 of file encodable_value_unittests.cc.

                                  {
  const char* hello = "Hello, world!";
  EncodableValue value(hello);
 
  EXPECT_EQ(std::get<std::string>(value), hello);
  value = "Goodbye";
  EXPECT_EQ(std::get<std::string>(value), "Goodbye");
}

TEST() [9/363]

flutter::TEST	(	EncodableValueTest	,
		DeepCopy
	)

Definition at line 247 of file encodable_value_unittests.cc.

                                   {
  EncodableList original = {
      EncodableValue(EncodableMap{
          {EncodableValue(), EncodableValue(std::vector<int32_t>{1, 2, 3})},
          {EncodableValue(1), EncodableValue(INT64_C(0000))},
          {EncodableValue("two"), EncodableValue(7)},
      }),
      EncodableValue(EncodableList{
          EncodableValue(),
          EncodableValue(),
          EncodableValue(
              EncodableMap{{EncodableValue("a"), EncodableValue("b")}}),
      }),
  };
 
  EncodableValue copy(original);
  ASSERT_TRUE(std::holds_alternative<EncodableList>(copy));
 
  // Spot-check innermost collection values.
  auto& root_list = std::get<EncodableList>(copy);
  auto& first_child = std::get<EncodableMap>(root_list[0]);
  EXPECT_EQ(std::get<int32_t>(first_child[EncodableValue("two")]), 7);
  auto& second_child = std::get<EncodableList>(root_list[1]);
  auto& innermost_map = std::get<EncodableMap>(second_child[2]);
  EXPECT_EQ(std::get<std::string>(innermost_map[EncodableValue("a")]), "b");
 
  // Modify those values in the original structure.
  first_child[EncodableValue("two")] = EncodableValue();
  innermost_map[EncodableValue("a")] = 99;
 
  // Re-check innermost collection values of the original to ensure that they
  // haven't changed.
  first_child = std::get<EncodableMap>(original[0]);
  EXPECT_EQ(std::get<int32_t>(first_child[EncodableValue("two")]), 7);
  second_child = std::get<EncodableList>(original[1]);
  innermost_map = std::get<EncodableMap>(second_child[2]);
  EXPECT_EQ(std::get<std::string>(innermost_map[EncodableValue("a")]), "b");
}

TEST() [10/363]

flutter::TEST	(	EncodableValueTest	,
		Double
	)

Definition at line 50 of file encodable_value_unittests.cc.

                                 {
  EncodableValue value(3.14);
 
  EXPECT_EQ(std::get<double>(value), 3.14);
  value = std::numeric_limits<double>::max();
  EXPECT_EQ(std::get<double>(value), std::numeric_limits<double>::max());
}

TEST() [11/363]

flutter::TEST	(	EncodableValueTest	,
		DoubleList
	)

Definition at line 119 of file encodable_value_unittests.cc.

                                     {
  std::vector<double> data = {-10.0, 2.0};
  EncodableValue value(data);
 
  auto& list_value = std::get<std::vector<double>>(value);
  list_value.push_back(std::numeric_limits<double>::max());
  EXPECT_EQ(list_value[0], -10.0);
  EXPECT_EQ(list_value[1], 2.0);
 
  ASSERT_EQ(list_value.size(), 3u);
  EXPECT_EQ(data.size(), 2u);
  EXPECT_EQ(list_value[2], std::numeric_limits<double>::max());
}

TEST() [12/363]

flutter::TEST	(	EncodableValueTest	,
		Int
	)

Definition at line 26 of file encodable_value_unittests.cc.

                              {
  EncodableValue value(42);
 
  EXPECT_EQ(std::get<int32_t>(value), 42);
  value = std::numeric_limits<int32_t>::max();
  EXPECT_EQ(std::get<int32_t>(value), std::numeric_limits<int32_t>::max());
}

TEST() [13/363]

flutter::TEST	(	EncodableValueTest	,
		Int32List
	)

Definition at line 91 of file encodable_value_unittests.cc.

                                    {
  std::vector<int32_t> data = {-10, 2};
  EncodableValue value(data);
 
  auto& list_value = std::get<std::vector<int32_t>>(value);
  list_value.push_back(std::numeric_limits<int32_t>::max());
  EXPECT_EQ(list_value[0], -10);
  EXPECT_EQ(list_value[1], 2);
 
  ASSERT_EQ(list_value.size(), 3u);
  EXPECT_EQ(data.size(), 2u);
  EXPECT_EQ(list_value[2], std::numeric_limits<int32_t>::max());
}

TEST() [14/363]

flutter::TEST	(	EncodableValueTest	,
		Int64List
	)

Definition at line 105 of file encodable_value_unittests.cc.

                                    {
  std::vector<int64_t> data = {-10, 2};
  EncodableValue value(data);
 
  auto& list_value = std::get<std::vector<int64_t>>(value);
  list_value.push_back(std::numeric_limits<int64_t>::max());
  EXPECT_EQ(list_value[0], -10);
  EXPECT_EQ(list_value[1], 2);
 
  ASSERT_EQ(list_value.size(), 3u);
  EXPECT_EQ(data.size(), 2u);
  EXPECT_EQ(list_value[2], std::numeric_limits<int64_t>::max());
}

TEST() [15/363]

flutter::TEST	(	EncodableValueTest	,
		List
	)

Definition at line 133 of file encodable_value_unittests.cc.

                               {
  EncodableList encodables = {
      EncodableValue(1),
      EncodableValue(2.0),
      EncodableValue("Three"),
  };
  EncodableValue value(encodables);
 
  auto& list_value = std::get<EncodableList>(value);
  EXPECT_EQ(std::get<int32_t>(list_value[0]), 1);
  EXPECT_EQ(std::get<double>(list_value[1]), 2.0);
  EXPECT_EQ(std::get<std::string>(list_value[2]), "Three");
 
  // Ensure that it's a modifiable copy of the original array.
  list_value.push_back(EncodableValue(true));
  ASSERT_EQ(list_value.size(), 4u);
  EXPECT_EQ(encodables.size(), 3u);
  EXPECT_EQ(std::get<bool>(std::get<EncodableList>(value)[3]), true);
}

TEST() [16/363]

flutter::TEST	(	EncodableValueTest	,
		Long
	)

Definition at line 42 of file encodable_value_unittests.cc.

                               {
  EncodableValue value(INT64_C(42));
 
  EXPECT_EQ(std::get<int64_t>(value), 42);
  value = std::numeric_limits<int64_t>::max();
  EXPECT_EQ(std::get<int64_t>(value), std::numeric_limits<int64_t>::max());
}

TEST() [17/363]

flutter::TEST	(	EncodableValueTest	,
		LongValue
	)

Definition at line 35 of file encodable_value_unittests.cc.

                                    {
  const EncodableValue int_value(std::numeric_limits<int32_t>::max());
  EXPECT_EQ(int_value.LongValue(), std::numeric_limits<int32_t>::max());
  const EncodableValue long_value(std::numeric_limits<int64_t>::max());
  EXPECT_EQ(long_value.LongValue(), std::numeric_limits<int64_t>::max());
}

TEST() [18/363]

flutter::TEST	(	EncodableValueTest	,
		Map
	)

Definition at line 153 of file encodable_value_unittests.cc.

                              {
  EncodableMap encodables = {
      {EncodableValue(), EncodableValue(std::vector<int32_t>{1, 2, 3})},
      {EncodableValue(1), EncodableValue(INT64_C(10000))},
      {EncodableValue("two"), EncodableValue(7)},
  };
  EncodableValue value(encodables);
 
  auto& map_value = std::get<EncodableMap>(value);
  EXPECT_EQ(
      std::holds_alternative<std::vector<int32_t>>(map_value[EncodableValue()]),
      true);
  EXPECT_EQ(std::get<int64_t>(map_value[EncodableValue(1)]), INT64_C(10000));
  EXPECT_EQ(std::get<int32_t>(map_value[EncodableValue("two")]), 7);
 
  // Ensure that it's a modifiable copy of the original map.
  map_value[EncodableValue(true)] = EncodableValue(false);
  ASSERT_EQ(map_value.size(), 4u);
  EXPECT_EQ(encodables.size(), 3u);
  EXPECT_EQ(std::get<bool>(map_value[EncodableValue(true)]), false);
}

TEST() [19/363]

flutter::TEST	(	EncodableValueTest	,
		Null
	)

Definition at line 13 of file encodable_value_unittests.cc.

                               {
  EncodableValue value;
  value.IsNull();
}

TEST() [20/363]

flutter::TEST	(	EncodableValueTest	,
		String
	)

Definition at line 58 of file encodable_value_unittests.cc.

                                 {
  std::string hello("Hello, world!");
  EncodableValue value(hello);
 
  EXPECT_EQ(std::get<std::string>(value), hello);
  value = std::string("Goodbye");
  EXPECT_EQ(std::get<std::string>(value), "Goodbye");
}

TEST() [21/363]

flutter::TEST	(	EncodableValueTest	,
		TypeIndexesCorrect
	)

Definition at line 301 of file encodable_value_unittests.cc.

                                             {
  // Null
  EXPECT_EQ(EncodableValue().index(), 0u);
  // Bool
  EXPECT_EQ(EncodableValue(true).index(), 1u);
  // Int32
  EXPECT_EQ(EncodableValue(100).index(), 2u);
  // Int64
  EXPECT_EQ(EncodableValue(INT64_C(100)).index(), 3u);
  // Double
  EXPECT_EQ(EncodableValue(7.0).index(), 4u);
  // String
  EXPECT_EQ(EncodableValue("one").index(), 5u);
  // ByteList
  EXPECT_EQ(EncodableValue(std::vector<uint8_t>()).index(), 6u);
  // IntList
  EXPECT_EQ(EncodableValue(std::vector<int32_t>()).index(), 7u);
  // LongList
  EXPECT_EQ(EncodableValue(std::vector<int64_t>()).index(), 8u);
  // DoubleList
  EXPECT_EQ(EncodableValue(std::vector<double>()).index(), 9u);
  // List
  EXPECT_EQ(EncodableValue(EncodableList()).index(), 10u);
  // Map
  EXPECT_EQ(EncodableValue(EncodableMap()).index(), 11u);
  // Custom type
  TestCustomValue customValue;
  EXPECT_EQ(((EncodableValue)CustomEncodableValue(customValue)).index(), 12u);
  // FloatList
  EXPECT_EQ(EncodableValue(std::vector<float>()).index(), 13u);
}  // namespace flutter

TEST() [22/363]

flutter::TEST	(	EncodableValueTest	,
		UInt8List
	)

Definition at line 77 of file encodable_value_unittests.cc.

                                    {
  std::vector<uint8_t> data = {0, 2};
  EncodableValue value(data);
 
  auto& list_value = std::get<std::vector<uint8_t>>(value);
  list_value.push_back(std::numeric_limits<uint8_t>::max());
  EXPECT_EQ(list_value[0], 0);
  EXPECT_EQ(list_value[1], 2);
 
  ASSERT_EQ(list_value.size(), 3u);
  EXPECT_EQ(data.size(), 2u);
  EXPECT_EQ(list_value[2], std::numeric_limits<uint8_t>::max());
}

TEST() [23/363]

flutter::TEST	(	EventChannelTest	,
		Cancel
	)

Definition at line 102 of file event_channel_unittests.cc.

                               {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EventChannel channel(&messenger, channel_name, &codec);
 
  bool on_listen_called = false;
  bool on_cancel_called = false;
  auto handler = std::make_unique<StreamHandlerFunctions<>>(
      [&on_listen_called](const EncodableValue* arguments,
                          std::unique_ptr<EventSink<>>&& events)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_listen_called = true;
        return nullptr;
      },
      [&on_cancel_called](const EncodableValue* arguments)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_cancel_called = true;
        return nullptr;
      });
  channel.SetStreamHandler(std::move(handler));
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  // Send test listen message.
  MethodCall<> call_listen("listen", nullptr);
  auto message = codec.EncodeMethodCall(call_listen);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
  EXPECT_EQ(on_listen_called, true);
 
  // Send test cancel message.
  MethodCall<> call_cancel("cancel", nullptr);
  message = codec.EncodeMethodCall(call_cancel);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
 
  // Check results.
  EXPECT_EQ(on_cancel_called, true);
}

TEST() [24/363]

flutter::TEST	(	EventChannelTest	,
		HandlerOutlivesEventChannel
	)

Definition at line 232 of file event_channel_unittests.cc.

                                                    {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
 
  bool on_listen_called = false;
  bool on_cancel_called = false;
  {
    EventChannel channel(&messenger, channel_name, &codec);
    auto handler = std::make_unique<StreamHandlerFunctions<>>(
        [&on_listen_called](const EncodableValue* arguments,
                            std::unique_ptr<EventSink<>>&& events)
            -> std::unique_ptr<StreamHandlerError<>> {
          on_listen_called = true;
          return nullptr;
        },
        [&on_cancel_called](const EncodableValue* arguments)
            -> std::unique_ptr<StreamHandlerError<>> {
          on_cancel_called = true;
          return nullptr;
        });
    channel.SetStreamHandler(std::move(handler));
  }
 
  // The event channel was destroyed but the handler should still be alive.
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  // Send test listen message.
  MethodCall<> call_listen("listen", nullptr);
  auto message = codec.EncodeMethodCall(call_listen);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
  EXPECT_EQ(on_listen_called, true);
 
  // Send test cancel message.
  MethodCall<> call_cancel("cancel", nullptr);
  message = codec.EncodeMethodCall(call_cancel);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
  EXPECT_EQ(on_cancel_called, true);
}

TEST() [25/363]

flutter::TEST	(	EventChannelTest	,
		ListenNotCancel
	)

Definition at line 146 of file event_channel_unittests.cc.

                                        {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EventChannel channel(&messenger, channel_name, &codec);
 
  bool on_listen_called = false;
  bool on_cancel_called = false;
  auto handler = std::make_unique<StreamHandlerFunctions<>>(
      [&on_listen_called](const EncodableValue* arguments,
                          std::unique_ptr<EventSink<>>&& events)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_listen_called = true;
        return nullptr;
      },
      [&on_cancel_called](const EncodableValue* arguments)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_cancel_called = true;
        return nullptr;
      });
  channel.SetStreamHandler(std::move(handler));
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  // Send test listen message.
  MethodCall<> call_listen("listen", nullptr);
  auto message = codec.EncodeMethodCall(call_listen);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
 
  // Check results.
  EXPECT_EQ(on_listen_called, true);
  EXPECT_EQ(on_cancel_called, false);
}

TEST() [26/363]

flutter::TEST	(	EventChannelTest	,
		Registration
	)

Definition at line 49 of file event_channel_unittests.cc.

                                     {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EventChannel channel(&messenger, channel_name, &codec);
 
  bool on_listen_called = false;
  auto handler = std::make_unique<StreamHandlerFunctions<>>(
      [&on_listen_called](const EncodableValue* arguments,
                          std::unique_ptr<EventSink<>>&& events)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_listen_called = true;
        return nullptr;
      },
      [](const EncodableValue* arguments)
          -> std::unique_ptr<StreamHandlerError<>> { return nullptr; });
  channel.SetStreamHandler(std::move(handler));
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  // Send test listen message.
  MethodCall<> call("listen", nullptr);
  auto message = codec.EncodeMethodCall(call);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
 
  // Check results.
  EXPECT_EQ(on_listen_called, true);
}

TEST() [27/363]

flutter::TEST	(	EventChannelTest	,
		ReRegistration
	)

Definition at line 186 of file event_channel_unittests.cc.

                                       {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EventChannel channel(&messenger, channel_name, &codec);
 
  bool on_listen_called = false;
  bool on_cancel_called = false;
  auto handler = std::make_unique<StreamHandlerFunctions<>>(
      [&on_listen_called](const EncodableValue* arguments,
                          std::unique_ptr<EventSink<>>&& events)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_listen_called = true;
        return nullptr;
      },
      [&on_cancel_called](const EncodableValue* arguments)
          -> std::unique_ptr<StreamHandlerError<>> {
        on_cancel_called = true;
        return nullptr;
      });
  channel.SetStreamHandler(std::move(handler));
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  // Send test listen message.
  MethodCall<> call("listen", nullptr);
  auto message = codec.EncodeMethodCall(call);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
  EXPECT_EQ(on_listen_called, true);
 
  // Send second test message to test StreamHandler's OnCancel
  // method is called before OnListen method is called.
  on_listen_called = false;
  message = codec.EncodeMethodCall(call);
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, const size_t reply_size) {});
 
  // Check results.
  EXPECT_EQ(on_cancel_called, true);
  EXPECT_EQ(on_listen_called, true);
}

TEST() [28/363]

flutter::TEST	(	EventChannelTest	,
		StreamHandlerErrorNullptr
	)

Definition at line 295 of file event_channel_unittests.cc.

                                                  {
  std::unique_ptr<StreamHandlerError<>> error =
      std::make_unique<StreamHandlerError<>>("Code", "Message", nullptr);
 
  ASSERT_NE(error.get(), nullptr);
  EXPECT_FALSE(error->error_details);
}

TEST() [29/363]

flutter::TEST	(	EventChannelTest	,
		StreamHandlerErrorPassByValue
	)

Definition at line 277 of file event_channel_unittests.cc.

                                                      {
  std::unique_ptr<StreamHandlerError<>> error = nullptr;
 
  {
    std::string code = "Code";
    std::string msg = "Message";
    std::unique_ptr<EncodableValue> details =
        std::make_unique<EncodableValue>("Details");
    error =
        std::make_unique<StreamHandlerError<>>(code, msg, std::move(details));
  }
 
  ASSERT_NE(error.get(), nullptr);
  EXPECT_EQ(error->error_code, "Code");
  EXPECT_EQ(error->error_message, "Message");
  EXPECT_EQ(std::get<std::string>(*error->error_details), "Details");
}

TEST() [30/363]

flutter::TEST	(	EventChannelTest	,
		Unregistration
	)

Definition at line 81 of file event_channel_unittests.cc.

                                       {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EventChannel channel(&messenger, channel_name, &codec);
 
  auto handler = std::make_unique<StreamHandlerFunctions<>>(
      [](const EncodableValue* arguments, std::unique_ptr<EventSink<>>&& events)
          -> std::unique_ptr<StreamHandlerError<>> { return nullptr; },
      [](const EncodableValue* arguments)
          -> std::unique_ptr<StreamHandlerError<>> { return nullptr; });
  channel.SetStreamHandler(std::move(handler));
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  channel.SetStreamHandler(nullptr);
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_EQ(messenger.last_message_handler(), nullptr);
}

TEST() [31/363]

flutter::TEST	(	FlowTest	,
		SurfaceFrameDoesNotHaveEmptyCanvas
	)

Definition at line 26 of file surface_frame_unittests.cc.

                                                   {
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto callback = [](const SurfaceFrame&, DlCanvas*) { return true; };
  SurfaceFrame frame(
      /*surface=*/nullptr,
      /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/callback,
      /*frame_size=*/SkISize::Make(800, 600),
      /*context_result=*/nullptr,
      /*display_list_fallback=*/true);
 
  EXPECT_FALSE(frame.Canvas()->GetLocalClipBounds().isEmpty());
  EXPECT_FALSE(frame.Canvas()->QuickReject(SkRect::MakeLTRB(10, 10, 50, 50)));
}

TEST() [32/363]

flutter::TEST	(	FlowTest	,
		SurfaceFrameDoesNotPrepareRtree
	)

Definition at line 41 of file surface_frame_unittests.cc.

                                                {
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto callback = [](const SurfaceFrame&, DlCanvas*) { return true; };
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/nullptr,
      /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/callback,
      /*frame_size=*/SkISize::Make(800, 600),
      /*context_result=*/nullptr,
      /*display_list_fallback=*/true);
  surface_frame->Canvas()->DrawRect(SkRect::MakeWH(100, 100), DlPaint());
  EXPECT_FALSE(surface_frame->BuildDisplayList()->has_rtree());
}

TEST() [33/363]

flutter::TEST	(	FlowTest	,
		SurfaceFrameDoesNotSubmitInDtor
	)

Definition at line 12 of file surface_frame_unittests.cc.

                                                {
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto callback = [](const SurfaceFrame&, DlCanvas*) {
    EXPECT_FALSE(true);
    return true;
  };
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/nullptr,
      /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/callback,
      /*frame_size=*/SkISize::Make(800, 600));
  surface_frame.reset();
}

TEST() [34/363]

flutter::TEST	(	FlutterEngineTest	,
		CreateDestroy
	)

Definition at line 51 of file flutter_engine_unittests.cc.

                                       {
  const std::string icu_data_path = "fake/path/to/icu";
  const std::string assets_path = "fake/path/to/assets";
  testing::ScopedStubFlutterGlfwApi scoped_api_stub(
      std::make_unique<TestGlfwApi>());
  auto test_api = static_cast<TestGlfwApi*>(scoped_api_stub.stub());
  {
    FlutterEngine engine;
    engine.Start(icu_data_path, assets_path, {});
    EXPECT_EQ(test_api->run_called(), true);
    EXPECT_EQ(test_api->shut_down_called(), false);
  }
  // Destroying should implicitly shut down if it hasn't been done manually.
  EXPECT_EQ(test_api->shut_down_called(), true);
}

TEST() [35/363]

flutter::TEST	(	FlutterEngineTest	,
		CreateDestroyWithCustomEntrypoint
	)

Definition at line 118 of file flutter_engine_unittests.cc.

                                                           {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
  {
    DartProject project(L"fake/project/path");
    project.set_dart_entrypoint("customEntrypoint");
    FlutterEngine engine(project);
    engine.Run();
    EXPECT_EQ(test_api->create_called(), true);
    EXPECT_EQ(test_api->run_called(), true);
    EXPECT_EQ(test_api->destroy_called(), false);
  }
  // Destroying should implicitly shut down if it hasn't been done manually.
  EXPECT_EQ(test_api->destroy_called(), true);
}

TEST() [36/363]

flutter::TEST	(	FlutterEngineTest	,
		DartEntrypointArgs
	)

Definition at line 183 of file flutter_engine_unittests.cc.

                                            {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
 
  DartProject project(L"data");
  std::vector<std::string> arguments = {"one", "two"};
  project.set_dart_entrypoint_arguments(arguments);
 
  FlutterEngine engine(project);
  const std::vector<std::string>& arguments_ref =
      test_api->dart_entrypoint_arguments();
  ASSERT_EQ(2, arguments_ref.size());
  EXPECT_TRUE(arguments[0] == arguments_ref[0]);
  EXPECT_TRUE(arguments[1] == arguments_ref[1]);
}

TEST() [37/363]

flutter::TEST	(	FlutterEngineTest	,
		ExplicitShutDown
	)

Definition at line 67 of file flutter_engine_unittests.cc.

                                          {
  const std::string icu_data_path = "fake/path/to/icu";
  const std::string assets_path = "fake/path/to/assets";
  testing::ScopedStubFlutterGlfwApi scoped_api_stub(
      std::make_unique<TestGlfwApi>());
  auto test_api = static_cast<TestGlfwApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine;
  engine.Start(icu_data_path, assets_path, {});
  EXPECT_EQ(test_api->run_called(), true);
  EXPECT_EQ(test_api->shut_down_called(), false);
  engine.ShutDown();
  EXPECT_EQ(test_api->shut_down_called(), true);
}

TEST() [38/363]

flutter::TEST	(	FlutterEngineTest	,
		GetMessenger
	)

Definition at line 173 of file flutter_engine_unittests.cc.

                                      {
  DartProject project(L"data");
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine(DartProject(L"fake/project/path"));
  EXPECT_NE(engine.messenger(), nullptr);
}

TEST() [39/363]

flutter::TEST	(	FlutterEngineTest	,
		ProcessExternalWindowMessage
	)

Definition at line 218 of file flutter_engine_unittests.cc.

                                                      {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine(DartProject(L"fake/project/path"));
 
  engine.ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), 1234, 0, 0);
 
  EXPECT_EQ(test_api->last_external_message(), 1234);
}

TEST() [40/363]

flutter::TEST	(	FlutterEngineTest	,
		ProcessMessages
	)

Definition at line 149 of file flutter_engine_unittests.cc.

                                         {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine(DartProject(L"fake/project/path"));
  engine.Run();
 
  std::chrono::nanoseconds next_event_time = engine.ProcessMessages();
  EXPECT_EQ(next_event_time.count(), 99);
}

TEST() [41/363]

flutter::TEST	(	FlutterEngineTest	,
		ReloadFonts
	)

Definition at line 161 of file flutter_engine_unittests.cc.

                                     {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine(DartProject(L"fake/project/path"));
  engine.Run();
 
  engine.ReloadSystemFonts();
  EXPECT_TRUE(test_api->reload_fonts_called());
}

TEST() [42/363]

flutter::TEST	(	FlutterEngineTest	,
		RunloopTimeoutTranslation
	)

Definition at line 82 of file flutter_engine_unittests.cc.

                                                   {
  const std::string icu_data_path = "fake/path/to/icu";
  const std::string assets_path = "fake/path/to/assets";
  testing::ScopedStubFlutterGlfwApi scoped_api_stub(
      std::make_unique<TestGlfwApi>());
  auto test_api = static_cast<TestGlfwApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine;
  engine.Start(icu_data_path, assets_path, {});
 
  engine.RunEventLoopWithTimeout(std::chrono::milliseconds(100));
  EXPECT_EQ(test_api->last_run_loop_timeout(), 100U);
 
  engine.RunEventLoopWithTimeout(std::chrono::milliseconds::max() -
                                 std::chrono::milliseconds(1));
  EXPECT_EQ(test_api->last_run_loop_timeout(), UINT32_MAX);
 
  engine.RunEventLoopWithTimeout(std::chrono::milliseconds::max());
  EXPECT_EQ(test_api->last_run_loop_timeout(), 0U);
}

TEST() [43/363]

flutter::TEST	(	FlutterEngineTest	,
		SetNextFrameCallback
	)

Definition at line 200 of file flutter_engine_unittests.cc.

                                              {
  DartProject project(L"data");
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestFlutterWindowsApi>());
  auto test_api = static_cast<TestFlutterWindowsApi*>(scoped_api_stub.stub());
 
  FlutterEngine engine(DartProject(L"fake/project/path"));
 
  bool success = false;
  engine.SetNextFrameCallback([&success]() { success = true; });
 
  EXPECT_TRUE(test_api->has_next_frame_callback());
 
  test_api->run_next_frame_callback();
 
  EXPECT_TRUE(success);
}

TEST() [44/363]

flutter::TEST	(	FlutterProjectBundle	,
		Switches
	)

Definition at line 50 of file engine_switches_unittests.cc.

                                     {
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCHES", "2");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_1", "abc");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
 
  std::vector<std::string> switches = GetSwitchesFromEnvironment();
  EXPECT_EQ(switches.size(), 2U);
  EXPECT_EQ(switches[0], "--abc");
  EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
}

TEST() [45/363]

flutter::TEST	(	FlutterProjectBundle	,
		SwitchesEmpty
	)

Definition at line 31 of file engine_switches_unittests.cc.

                                          {
  // Clear the main environment variable, since test order is not guaranteed.
  ClearEnvironmentVariable("FLUTTER_ENGINE_SWITCHES");
 
  EXPECT_EQ(GetSwitchesFromEnvironment().size(), 0U);
}

TEST() [46/363]

flutter::TEST	(	FlutterProjectBundle	,
		SwitchesExtraValues
	)

Definition at line 61 of file engine_switches_unittests.cc.

                                                {
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCHES", "1");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_1", "abc");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
 
  std::vector<std::string> switches = GetSwitchesFromEnvironment();
  EXPECT_EQ(switches.size(), 1U);
  EXPECT_EQ(switches[0], "--abc");
}

TEST() [47/363]

flutter::TEST	(	FlutterProjectBundle	,
		SwitchesMissingValues
	)

Definition at line 71 of file engine_switches_unittests.cc.

                                                  {
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCHES", "4");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_1", "abc");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
  ClearEnvironmentVariable("FLUTTER_ENGINE_SWITCH_3");
  SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_4", "oops");
 
  std::vector<std::string> switches = GetSwitchesFromEnvironment();
  EXPECT_EQ(switches.size(), 3U);
  EXPECT_EQ(switches[0], "--abc");
  EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
  // The missing switch should be skipped, leaving SWITCH_4 as the third
  // switch in the array.
  EXPECT_EQ(switches[2], "--oops");
}

TEST() [48/363]

flutter::TEST	(	FlutterViewControllerTest	,
		CreateDestroy
	)

Definition at line 40 of file flutter_window_controller_unittests.cc.

                                               {
  const std::string icu_data_path = "fake/path/to/icu";
  testing::ScopedStubFlutterGlfwApi scoped_api_stub(
      std::make_unique<TestGlfwApi>());
  auto test_api = static_cast<TestGlfwApi*>(scoped_api_stub.stub());
  {
    FlutterWindowController controller(icu_data_path);
    EXPECT_EQ(test_api->init_called(), true);
    EXPECT_EQ(test_api->terminate_called(), false);
  }
  EXPECT_EQ(test_api->init_called(), true);
  EXPECT_EQ(test_api->terminate_called(), true);
}

TEST() [49/363]

flutter::TEST	(	FlutterViewControllerTest	,
		ForceRedraw
	)

Definition at line 100 of file flutter_view_controller_unittests.cc.

                                             {
  DartProject project(L"data");
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestWindowsApi>());
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  FlutterViewController controller(100, 100, project);
 
  controller.ForceRedraw();
  EXPECT_TRUE(test_api->view_controller_force_redrawed());
}

TEST() [50/363]

flutter::TEST	(	FlutterViewControllerTest	,
		GetEngine
	)

Definition at line 82 of file flutter_view_controller_unittests.cc.

                                           {
  DartProject project(L"data");
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestWindowsApi>());
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  FlutterViewController controller(100, 100, project);
  EXPECT_NE(controller.engine(), nullptr);
}

TEST() [51/363]

flutter::TEST	(	FlutterViewControllerTest	,
		GetView
	)

Definition at line 91 of file flutter_view_controller_unittests.cc.

                                         {
  DartProject project(L"data");
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestWindowsApi>());
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  FlutterViewController controller(100, 100, project);
  EXPECT_NE(controller.view(), nullptr);
}

TEST() [52/363]

flutter::TEST	(	FlutterViewControllerTest	,
		GetViewId
	)

Definition at line 73 of file flutter_view_controller_unittests.cc.

                                           {
  DartProject project(L"data");
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestWindowsApi>());
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  FlutterViewController controller(100, 100, project);
  EXPECT_EQ(controller.view_id(), 1);
}

TEST() [53/363]

flutter::TEST	(	FlutterViewTest	,
		GraphicsAdapterAccessPassesThrough
	)

Definition at line 35 of file flutter_view_unittests.cc.

                                                          {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestWindowsApi>());
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  FlutterView view(reinterpret_cast<FlutterDesktopViewRef>(2));
 
  IDXGIAdapter* adapter = view.GetGraphicsAdapter();
  EXPECT_EQ(adapter, reinterpret_cast<IDXGIAdapter*>(8));
}

TEST() [54/363]

flutter::TEST	(	FlutterViewTest	,
		HwndAccessPassesThrough
	)

Definition at line 27 of file flutter_view_unittests.cc.

                                               {
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(
      std::make_unique<TestWindowsApi>());
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  FlutterView view(reinterpret_cast<FlutterDesktopViewRef>(2));
  EXPECT_EQ(view.GetNativeWindow(), reinterpret_cast<HWND>(7));
}

TEST() [55/363]

flutter::TEST	(	FlutterWindowTest	,
		SetSizeLimits
	)

Definition at line 34 of file flutter_window_unittests.cc.

                                       {
  const std::string icu_data_path = "fake/path/to/icu";
  testing::ScopedStubFlutterGlfwApi scoped_api_stub(
      std::make_unique<TestGlfwApi>());
  auto test_api = static_cast<TestGlfwApi*>(scoped_api_stub.stub());
  // This is not actually used so any non-zero value works.
  auto raw_window = reinterpret_cast<FlutterDesktopWindowRef>(1);
 
  auto window = std::make_unique<FlutterWindow>(raw_window);
 
  FlutterDesktopSize minimum_size = {};
  minimum_size.width = 100;
  minimum_size.height = 100;
 
  FlutterDesktopSize maximum_size = {};
  maximum_size.width = -1;
  maximum_size.height = -1;
 
  window->SetSizeLimits(minimum_size, maximum_size);
 
  EXPECT_EQ(test_api->set_size_limits_called(), true);
}

TEST() [56/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameBuildEnd
	)

Definition at line 193 of file frame_timings_recorder_unittests.cc.

                                                      {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto now = fml::TimePoint::Now();
  recorder->RecordVsync(now, now + fml::TimeDelta::FromMilliseconds(16));
  recorder->RecordBuildStart(fml::TimePoint::Now());
  recorder->RecordBuildEnd(fml::TimePoint::Now());
 
  auto cloned = recorder->CloneUntil(FrameTimingsRecorder::State::kBuildEnd);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
  ASSERT_EQ(recorder->GetVsyncStartTime(), cloned->GetVsyncStartTime());
  ASSERT_EQ(recorder->GetVsyncTargetTime(), cloned->GetVsyncTargetTime());
  ASSERT_EQ(recorder->GetBuildStartTime(), cloned->GetBuildStartTime());
  ASSERT_EQ(recorder->GetBuildEndTime(), cloned->GetBuildEndTime());
}

TEST() [57/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameBuildStart
	)

Definition at line 179 of file frame_timings_recorder_unittests.cc.

                                                        {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto now = fml::TimePoint::Now();
  recorder->RecordVsync(now, now + fml::TimeDelta::FromMilliseconds(16));
  recorder->RecordBuildStart(fml::TimePoint::Now());
 
  auto cloned = recorder->CloneUntil(FrameTimingsRecorder::State::kBuildStart);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
  ASSERT_EQ(recorder->GetVsyncStartTime(), cloned->GetVsyncStartTime());
  ASSERT_EQ(recorder->GetVsyncTargetTime(), cloned->GetVsyncTargetTime());
  ASSERT_EQ(recorder->GetBuildStartTime(), cloned->GetBuildStartTime());
}

TEST() [58/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameFrameNumber
	)

Definition at line 159 of file frame_timings_recorder_unittests.cc.

                                                         {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  auto cloned =
      recorder->CloneUntil(FrameTimingsRecorder::State::kUninitialized);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
}

TEST() [59/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameRasterEnd
	)

Definition at line 227 of file frame_timings_recorder_unittests.cc.

                                                       {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto now = fml::TimePoint::Now();
  recorder->RecordVsync(now, now + fml::TimeDelta::FromMilliseconds(16));
  recorder->RecordBuildStart(fml::TimePoint::Now());
  recorder->RecordBuildEnd(fml::TimePoint::Now());
  recorder->RecordRasterStart(fml::TimePoint::Now());
  recorder->RecordRasterEnd();
 
  auto cloned = recorder->CloneUntil(FrameTimingsRecorder::State::kRasterEnd);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
  ASSERT_EQ(recorder->GetVsyncStartTime(), cloned->GetVsyncStartTime());
  ASSERT_EQ(recorder->GetVsyncTargetTime(), cloned->GetVsyncTargetTime());
  ASSERT_EQ(recorder->GetBuildStartTime(), cloned->GetBuildStartTime());
  ASSERT_EQ(recorder->GetBuildEndTime(), cloned->GetBuildEndTime());
  ASSERT_EQ(recorder->GetRasterStartTime(), cloned->GetRasterStartTime());
  ASSERT_EQ(recorder->GetRasterEndTime(), cloned->GetRasterEndTime());
  ASSERT_EQ(recorder->GetRasterEndWallTime(), cloned->GetRasterEndWallTime());
  ASSERT_EQ(recorder->GetLayerCacheCount(), cloned->GetLayerCacheCount());
  ASSERT_EQ(recorder->GetLayerCacheBytes(), cloned->GetLayerCacheBytes());
  ASSERT_EQ(recorder->GetPictureCacheCount(), cloned->GetPictureCacheCount());
  ASSERT_EQ(recorder->GetPictureCacheBytes(), cloned->GetPictureCacheBytes());
}

TEST() [60/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameRasterEndWithCache
	)

Definition at line 252 of file frame_timings_recorder_unittests.cc.

                                                                {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
  MockRasterCache cache(1, 10);
  cache.BeginFrame();
 
  const auto now = fml::TimePoint::Now();
  recorder->RecordVsync(now, now + fml::TimeDelta::FromMilliseconds(16));
  recorder->RecordBuildStart(fml::TimePoint::Now());
  recorder->RecordBuildEnd(fml::TimePoint::Now());
  recorder->RecordRasterStart(fml::TimePoint::Now());
 
  cache.AddMockLayer(100, 100);
  size_t layer_bytes = cache.EstimateLayerCacheByteSize();
  EXPECT_GT(layer_bytes, 0u);
  cache.AddMockPicture(100, 100);
  size_t picture_bytes = cache.EstimatePictureCacheByteSize();
  EXPECT_GT(picture_bytes, 0u);
  cache.EvictUnusedCacheEntries();
  cache.EndFrame();
  recorder->RecordRasterEnd(&cache);
 
  auto cloned = recorder->CloneUntil(FrameTimingsRecorder::State::kRasterEnd);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
  ASSERT_EQ(recorder->GetVsyncStartTime(), cloned->GetVsyncStartTime());
  ASSERT_EQ(recorder->GetVsyncTargetTime(), cloned->GetVsyncTargetTime());
  ASSERT_EQ(recorder->GetBuildStartTime(), cloned->GetBuildStartTime());
  ASSERT_EQ(recorder->GetBuildEndTime(), cloned->GetBuildEndTime());
  ASSERT_EQ(recorder->GetRasterStartTime(), cloned->GetRasterStartTime());
  ASSERT_EQ(recorder->GetRasterEndTime(), cloned->GetRasterEndTime());
  ASSERT_EQ(recorder->GetRasterEndWallTime(), cloned->GetRasterEndWallTime());
  ASSERT_EQ(recorder->GetLayerCacheCount(), cloned->GetLayerCacheCount());
  ASSERT_EQ(recorder->GetLayerCacheBytes(), cloned->GetLayerCacheBytes());
  ASSERT_EQ(recorder->GetPictureCacheCount(), cloned->GetPictureCacheCount());
  ASSERT_EQ(recorder->GetPictureCacheBytes(), cloned->GetPictureCacheBytes());
}

TEST() [61/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameRasterStart
	)

Definition at line 209 of file frame_timings_recorder_unittests.cc.

                                                         {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto now = fml::TimePoint::Now();
  recorder->RecordVsync(now, now + fml::TimeDelta::FromMilliseconds(16));
  recorder->RecordBuildStart(fml::TimePoint::Now());
  recorder->RecordBuildEnd(fml::TimePoint::Now());
  recorder->RecordRasterStart(fml::TimePoint::Now());
 
  auto cloned = recorder->CloneUntil(FrameTimingsRecorder::State::kRasterStart);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
  ASSERT_EQ(recorder->GetVsyncStartTime(), cloned->GetVsyncStartTime());
  ASSERT_EQ(recorder->GetVsyncTargetTime(), cloned->GetVsyncTargetTime());
  ASSERT_EQ(recorder->GetBuildStartTime(), cloned->GetBuildStartTime());
  ASSERT_EQ(recorder->GetBuildEndTime(), cloned->GetBuildEndTime());
  ASSERT_EQ(recorder->GetRasterStartTime(), cloned->GetRasterStartTime());
}

TEST() [62/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameVsyncStartAndTarget
	)

Definition at line 167 of file frame_timings_recorder_unittests.cc.

                                                                 {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto now = fml::TimePoint::Now();
  recorder->RecordVsync(now, now + fml::TimeDelta::FromMilliseconds(16));
 
  auto cloned = recorder->CloneUntil(FrameTimingsRecorder::State::kVsync);
  ASSERT_EQ(recorder->GetFrameNumber(), cloned->GetFrameNumber());
  ASSERT_EQ(recorder->GetVsyncStartTime(), cloned->GetVsyncStartTime());
  ASSERT_EQ(recorder->GetVsyncTargetTime(), cloned->GetVsyncTargetTime());
}

TEST() [63/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		FrameNumberTraceArgIsValid
	)

Definition at line 288 of file frame_timings_recorder_unittests.cc.

                                                           {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  char buff[50];
  sprintf(buff, "%d", static_cast<int>(recorder->GetFrameNumber()));
  std::string actual_arg = buff;
  std::string expected_arg = recorder->GetFrameNumberTraceArg();
 
  ASSERT_EQ(actual_arg, expected_arg);
}

TEST() [64/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordBuildTimes
	)

Definition at line 30 of file frame_timings_recorder_unittests.cc.

                                                 {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto st = fml::TimePoint::Now();
  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordVsync(st, en);
 
  const auto build_start = fml::TimePoint::Now();
  const auto build_end = build_start + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordBuildStart(build_start);
  recorder->RecordBuildEnd(build_end);
 
  ASSERT_EQ(build_start, recorder->GetBuildStartTime());
  ASSERT_EQ(build_end, recorder->GetBuildEndTime());
}

TEST() [65/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordersHaveUniqueFrameNumbers
	)

Definition at line 152 of file frame_timings_recorder_unittests.cc.

                                                                {
  auto recorder1 = std::make_unique<FrameTimingsRecorder>();
  auto recorder2 = std::make_unique<FrameTimingsRecorder>();
 
  ASSERT_TRUE(recorder2->GetFrameNumber() > recorder1->GetFrameNumber());
}

TEST() [66/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordRasterTimes
	)

Definition at line 46 of file frame_timings_recorder_unittests.cc.

                                                  {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto st = fml::TimePoint::Now();
  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordVsync(st, en);
 
  const auto build_start = fml::TimePoint::Now();
  const auto build_end = build_start + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordBuildStart(build_start);
  recorder->RecordBuildEnd(build_end);
 
  using namespace std::chrono_literals;
 
  const auto raster_start = fml::TimePoint::Now();
  recorder->RecordRasterStart(raster_start);
  const auto before_raster_end_wall_time = fml::TimePoint::CurrentWallTime();
  std::this_thread::sleep_for(1ms);
  const auto timing = recorder->RecordRasterEnd();
  std::this_thread::sleep_for(1ms);
  const auto after_raster_end_wall_time = fml::TimePoint::CurrentWallTime();
 
  ASSERT_EQ(raster_start, recorder->GetRasterStartTime());
  ASSERT_GT(recorder->GetRasterEndWallTime(), before_raster_end_wall_time);
  ASSERT_LT(recorder->GetRasterEndWallTime(), after_raster_end_wall_time);
  ASSERT_EQ(recorder->GetFrameNumber(), timing.GetFrameNumber());
  ASSERT_EQ(recorder->GetLayerCacheCount(), 0u);
  ASSERT_EQ(recorder->GetLayerCacheBytes(), 0u);
  ASSERT_EQ(recorder->GetPictureCacheCount(), 0u);
  ASSERT_EQ(recorder->GetPictureCacheBytes(), 0u);
}

TEST() [67/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordRasterTimesWithCache
	)

Definition at line 78 of file frame_timings_recorder_unittests.cc.

                                                           {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto st = fml::TimePoint::Now();
  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordVsync(st, en);
 
  const auto build_start = fml::TimePoint::Now();
  const auto build_end = build_start + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordBuildStart(build_start);
  recorder->RecordBuildEnd(build_end);
 
  using namespace std::chrono_literals;
 
  MockRasterCache cache(1, 10);
  cache.BeginFrame();
 
  const auto raster_start = fml::TimePoint::Now();
  recorder->RecordRasterStart(raster_start);
 
  cache.AddMockLayer(100, 100);
  size_t layer_bytes = cache.EstimateLayerCacheByteSize();
  EXPECT_GT(layer_bytes, 0u);
  cache.AddMockPicture(100, 100);
  size_t picture_bytes = cache.EstimatePictureCacheByteSize();
  EXPECT_GT(picture_bytes, 0u);
  cache.EvictUnusedCacheEntries();
 
  cache.EndFrame();
 
  const auto before_raster_end_wall_time = fml::TimePoint::CurrentWallTime();
  std::this_thread::sleep_for(1ms);
  const auto timing = recorder->RecordRasterEnd(&cache);
  std::this_thread::sleep_for(1ms);
  const auto after_raster_end_wall_time = fml::TimePoint::CurrentWallTime();
 
  ASSERT_EQ(raster_start, recorder->GetRasterStartTime());
  ASSERT_GT(recorder->GetRasterEndWallTime(), before_raster_end_wall_time);
  ASSERT_LT(recorder->GetRasterEndWallTime(), after_raster_end_wall_time);
  ASSERT_EQ(recorder->GetFrameNumber(), timing.GetFrameNumber());
  ASSERT_EQ(recorder->GetLayerCacheCount(), 1u);
  ASSERT_EQ(recorder->GetLayerCacheBytes(), layer_bytes);
  ASSERT_EQ(recorder->GetPictureCacheCount(), 1u);
  ASSERT_EQ(recorder->GetPictureCacheBytes(), picture_bytes);
}

TEST() [68/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordVsync
	)

Definition at line 20 of file frame_timings_recorder_unittests.cc.

                                            {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
  const auto st = fml::TimePoint::Now();
  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordVsync(st, en);
 
  ASSERT_EQ(st, recorder->GetVsyncStartTime());
  ASSERT_EQ(en, recorder->GetVsyncTargetTime());
}

TEST() [69/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ThrowWhenRecordBuildBeforeVsync
	)

Definition at line 128 of file frame_timings_recorder_unittests.cc.

                                                                {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto build_start = fml::TimePoint::Now();
  fml::Status status = recorder->RecordBuildStartImpl(build_start);
  EXPECT_FALSE(status.ok());
  EXPECT_EQ(status.message(), "Check failed: state_ == State::kVsync.");
}

TEST() [70/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ThrowWhenRecordRasterBeforeBuildEnd
	)

Definition at line 137 of file frame_timings_recorder_unittests.cc.

                                                                    {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  const auto st = fml::TimePoint::Now();
  const auto en = st + fml::TimeDelta::FromMillisecondsF(16);
  recorder->RecordVsync(st, en);
 
  const auto raster_start = fml::TimePoint::Now();
  fml::Status status = recorder->RecordRasterStartImpl(raster_start);
  EXPECT_FALSE(status.ok());
  EXPECT_EQ(status.message(), "Check failed: state_ == State::kBuildEnd.");
}

TEST() [71/363]

flutter::TEST	(	IncomingMessageDispatcher	,
		BlockInputFalse
	)

Definition at line 39 of file incoming_message_dispatcher_unittests.cc.

                                                 {
  FlutterDesktopMessengerRef messenger = nullptr;
  auto dispatcher = std::make_unique<IncomingMessageDispatcher>(messenger);
  bool did_call[3] = {false, false, false};
  dispatcher->SetMessageCallback(
      "hello",
      [](FlutterDesktopMessengerRef messenger,
         const FlutterDesktopMessage* message,
         void* user_data) { reinterpret_cast<bool*>(user_data)[0] = true; },
      &did_call);
  FlutterDesktopMessage message = {
      .struct_size = sizeof(FlutterDesktopMessage),
      .channel = "hello",
      .message = nullptr,
      .message_size = 0,
      .response_handle = nullptr,
  };
  dispatcher->HandleMessage(
      message, [&did_call] { did_call[1] = true; },
      [&did_call] { did_call[2] = true; });
  EXPECT_TRUE(did_call[0]);
  EXPECT_FALSE(did_call[1]);
  EXPECT_FALSE(did_call[2]);
}

TEST() [72/363]

flutter::TEST	(	IncomingMessageDispatcher	,
		BlockInputTrue
	)

Definition at line 64 of file incoming_message_dispatcher_unittests.cc.

                                                {
  FlutterDesktopMessengerRef messenger = nullptr;
  auto dispatcher = std::make_unique<IncomingMessageDispatcher>(messenger);
  static int counter = 0;
  int did_call[3] = {-1, -1, -1};
  dispatcher->EnableInputBlockingForChannel("hello");
  dispatcher->SetMessageCallback(
      "hello",
      [](FlutterDesktopMessengerRef messenger,
         const FlutterDesktopMessage* message,
         void* user_data) { reinterpret_cast<int*>(user_data)[counter++] = 1; },
      &did_call);
  FlutterDesktopMessage message = {
      .struct_size = sizeof(FlutterDesktopMessage),
      .channel = "hello",
      .message = nullptr,
      .message_size = 0,
      .response_handle = nullptr,
  };
  dispatcher->HandleMessage(
      message, [&did_call] { did_call[counter++] = 0; },
      [&did_call] { did_call[counter++] = 2; });
  EXPECT_EQ(did_call[0], 0);
  EXPECT_EQ(did_call[1], 1);
  EXPECT_EQ(did_call[2], 2);
}

TEST() [73/363]

flutter::TEST	(	IncomingMessageDispatcher	,
		SetHandle
	)

Definition at line 10 of file incoming_message_dispatcher_unittests.cc.

                                           {
  FlutterDesktopMessengerRef messenger =
      reinterpret_cast<FlutterDesktopMessengerRef>(0xfeedface);
  const uint8_t* message_data = reinterpret_cast<const uint8_t*>(0xcafebabe);
  auto dispatcher = std::make_unique<IncomingMessageDispatcher>(messenger);
  bool did_call = false;
  dispatcher->SetMessageCallback(
      "hello",
      [](FlutterDesktopMessengerRef messenger,
         const FlutterDesktopMessage* message, void* user_data) {
        EXPECT_EQ(messenger,
                  reinterpret_cast<FlutterDesktopMessengerRef>(0xfeedface));
        EXPECT_EQ(message->message,
                  reinterpret_cast<const uint8_t*>(0xcafebabe));
        EXPECT_EQ(message->message_size, 123u);
        *reinterpret_cast<bool*>(user_data) = true;
      },
      &did_call);
  FlutterDesktopMessage message = {
      .struct_size = sizeof(FlutterDesktopMessage),
      .channel = "hello",
      .message = message_data,
      .message_size = 123,
      .response_handle = nullptr,
  };
  dispatcher->HandleMessage(message);
  EXPECT_TRUE(did_call);
}

TEST() [74/363]

flutter::TEST	(	JsonMessageCodec	,
		EncodeDecode
	)

Definition at line 29 of file json_message_codec_unittests.cc.

                                     {
  // NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
  rapidjson::Document array(rapidjson::kArrayType);
  auto& allocator = array.GetAllocator();
 
  array.PushBack("string", allocator);
 
  rapidjson::Value map(rapidjson::kObjectType);
  map.AddMember("a", -7, allocator);
  map.AddMember("b", std::numeric_limits<int>::max(), allocator);
  map.AddMember("c", 3.14159, allocator);
  map.AddMember("d", true, allocator);
  map.AddMember("e", rapidjson::Value(), allocator);
  array.PushBack(map, allocator);
 
  CheckEncodeDecode(array);
}

TEST() [75/363]

flutter::TEST	(	JsonMethodCodec	,
		HandlesErrorEnvelopesWithDetails
	)

Definition at line 125 of file json_method_codec_unittests.cc.

                                                        {
  const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
  // NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
  rapidjson::Document details(rapidjson::kArrayType);
  auto& allocator = details.GetAllocator();
  details.PushBack("a", allocator);
  details.PushBack(42, allocator);
  auto encoded =
      codec.EncodeErrorEnvelope("errorCode", "something failed", &details);
  ASSERT_NE(encoded.get(), nullptr);
  std::vector<uint8_t> bytes = {
      '[', '"', 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e', '"', ',', '"',
      's', 'o', 'm', 'e', 't', 'h', 'i', 'n', 'g', ' ', 'f', 'a', 'i', 'l',
      'e', 'd', '"', ',', '[', '"', 'a', '"', ',', '4', '2', ']', ']',
  };
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<rapidjson::Document> result_handler(
      nullptr,
      [&decoded_successfully](const std::string& code,
                              const std::string& message,
                              const rapidjson::Document* details) {
        decoded_successfully = true;
        EXPECT_EQ(code, "errorCode");
        EXPECT_EQ(message, "something failed");
        EXPECT_TRUE(details->IsArray());
        EXPECT_EQ(std::string((*details)[0].GetString()), "a");
        EXPECT_EQ((*details)[1].GetInt(), 42);
      },
      nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [76/363]

flutter::TEST	(	JsonMethodCodec	,
		HandlesErrorEnvelopesWithNulls
	)

Definition at line 98 of file json_method_codec_unittests.cc.

                                                      {
  const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
  auto encoded = codec.EncodeErrorEnvelope("errorCode");
  ASSERT_TRUE(encoded);
  std::vector<uint8_t> bytes = {
      '[', '"', 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e',
      '"', ',', '"', '"', ',', 'n', 'u', 'l', 'l', ']',
  };
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<rapidjson::Document> result_handler(
      nullptr,
      [&decoded_successfully](const std::string& code,
                              const std::string& message,
                              const rapidjson::Document* details) {
        decoded_successfully = true;
        EXPECT_EQ(code, "errorCode");
        EXPECT_EQ(message, "");
        EXPECT_EQ(details, nullptr);
      },
      nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [77/363]

flutter::TEST	(	JsonMethodCodec	,
		HandlesMethodCallsWithArgument
	)

Definition at line 42 of file json_method_codec_unittests.cc.

                                                      {
  const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
 
  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
  auto& allocator = arguments->GetAllocator();
  arguments->PushBack(42, allocator);
  arguments->PushBack("world", allocator);
  MethodCall<rapidjson::Document> call("hello", std::move(arguments));
  auto encoded = codec.EncodeMethodCall(call);
  ASSERT_TRUE(encoded);
  std::unique_ptr<MethodCall<rapidjson::Document>> decoded =
      codec.DecodeMethodCall(*encoded);
  ASSERT_TRUE(decoded);
  EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
}

TEST() [78/363]

flutter::TEST	(	JsonMethodCodec	,
		HandlesMethodCallsWithNullArguments
	)

Definition at line 31 of file json_method_codec_unittests.cc.

                                                           {
  const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
  MethodCall<rapidjson::Document> call("hello", nullptr);
  auto encoded = codec.EncodeMethodCall(call);
  ASSERT_TRUE(encoded);
  std::unique_ptr<MethodCall<rapidjson::Document>> decoded =
      codec.DecodeMethodCall(*encoded);
  ASSERT_TRUE(decoded);
  EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
}

TEST() [79/363]

flutter::TEST	(	JsonMethodCodec	,
		HandlesSuccessEnvelopesWithNullResult
	)

Definition at line 58 of file json_method_codec_unittests.cc.

                                                             {
  const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
  auto encoded = codec.EncodeSuccessEnvelope();
  ASSERT_TRUE(encoded);
  std::vector<uint8_t> bytes = {'[', 'n', 'u', 'l', 'l', ']'};
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<rapidjson::Document> result_handler(
      [&decoded_successfully](const rapidjson::Document* result) {
        decoded_successfully = true;
        EXPECT_EQ(result, nullptr);
      },
      nullptr, nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [80/363]

flutter::TEST	(	JsonMethodCodec	,
		HandlesSuccessEnvelopesWithResult
	)

Definition at line 77 of file json_method_codec_unittests.cc.

                                                         {
  const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
  rapidjson::Document result;
  result.SetInt(42);
  auto encoded = codec.EncodeSuccessEnvelope(&result);
  ASSERT_TRUE(encoded);
  std::vector<uint8_t> bytes = {'[', '4', '2', ']'};
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<rapidjson::Document> result_handler(
      [&decoded_successfully](const rapidjson::Document* result) {
        decoded_successfully = true;
        EXPECT_EQ(result->GetInt(), 42);
      },
      nullptr, nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [81/363]

flutter::TEST	(	MethodCallTest	,
		Basic
	)

Definition at line 14 of file method_call_unittests.cc.

                            {
  const std::string method_name("method_name");
  const int argument = 42;
  MethodCall<int> method_call(method_name, std::make_unique<int>(argument));
  EXPECT_EQ(method_call.method_name(), method_name);
  ASSERT_NE(method_call.arguments(), nullptr);
  EXPECT_EQ(*method_call.arguments(), 42);
}

TEST() [82/363]

flutter::TEST	(	MethodChannelTest	,
		Error
	)

Definition at line 37 of file method_result_functions_unittests.cc.

                               {
  bool called = false;
  std::string error_code = "a";
  std::string error_message = "b";
  int error_details = 1;
  MethodResultFunctions<int> result(
      nullptr,
      [&called, error_code, error_message, error_details](
          const std::string& code, const std::string& message,
          const int* details) {
        called = true;
        EXPECT_EQ(code, error_code);
        EXPECT_EQ(message, error_message);
        EXPECT_EQ(*details, error_details);
      },
      nullptr);
  result.Error(error_code, error_message, error_details);
  EXPECT_TRUE(called);
}

TEST() [83/363]

flutter::TEST	(	MethodChannelTest	,
		InvokeNotImplemented
	)

Definition at line 145 of file method_channel_unittests.cc.

                                              {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  MethodChannel channel(&messenger, channel_name,
                        &StandardMethodCodec::GetInstance());
 
  bool received_not_implemented = false;
  auto result_handler = std::make_unique<MethodResultFunctions<>>(
      nullptr, nullptr,
      [&received_not_implemented]() { received_not_implemented = true; });
 
  channel.InvokeMethod("foo", nullptr, std::move(result_handler));
  EXPECT_EQ(messenger.send_called(), true);
  ASSERT_NE(messenger.last_reply_handler(), nullptr);
 
  // Call the underlying reply handler to ensure it's reported as unimplemented.
  messenger.last_reply_handler()(nullptr, 0);
  EXPECT_TRUE(received_not_implemented);
}

TEST() [84/363]

flutter::TEST	(	MethodChannelTest	,
		InvokeWithoutResponse
	)

Definition at line 107 of file method_channel_unittests.cc.

                                               {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  MethodChannel channel(&messenger, channel_name,
                        &StandardMethodCodec::GetInstance());
 
  channel.InvokeMethod("foo", nullptr);
  EXPECT_TRUE(messenger.send_called());
  EXPECT_EQ(messenger.last_reply_handler(), nullptr);
}

TEST() [85/363]

flutter::TEST	(	MethodChannelTest	,
		InvokeWithResponse
	)

Definition at line 118 of file method_channel_unittests.cc.

                                            {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  MethodChannel channel(&messenger, channel_name,
                        &StandardMethodCodec::GetInstance());
 
  bool received_reply = false;
  const std::string reply = "bar";
  auto result_handler = std::make_unique<MethodResultFunctions<>>(
      [&received_reply, reply](const EncodableValue* success_value) {
        received_reply = true;
        EXPECT_EQ(std::get<std::string>(*success_value), reply);
      },
      nullptr, nullptr);
 
  channel.InvokeMethod("foo", nullptr, std::move(result_handler));
  EXPECT_TRUE(messenger.send_called());
  ASSERT_NE(messenger.last_reply_handler(), nullptr);
 
  // Call the underlying reply handler to ensure it's processed correctly.
  EncodableValue reply_value(reply);
  std::unique_ptr<std::vector<uint8_t>> encoded_reply =
      StandardMethodCodec::GetInstance().EncodeSuccessEnvelope(&reply_value);
  messenger.last_reply_handler()(encoded_reply->data(), encoded_reply->size());
  EXPECT_TRUE(received_reply);
}

TEST() [86/363]

flutter::TEST	(	MethodChannelTest	,
		NoHandlers
	)

Definition at line 15 of file method_result_functions_unittests.cc.

                                    {
  MethodResultFunctions<int> result(nullptr, nullptr, nullptr);
  result.Success();
  result.Error("error");
  result.NotImplemented();
}

TEST() [87/363]

flutter::TEST	(	MethodChannelTest	,
		NotImplemented
	)

Definition at line 58 of file method_result_functions_unittests.cc.

                                        {
  bool called = false;
  MethodResultFunctions<int> result(nullptr, nullptr,
                                    [&called]() { called = true; });
  result.NotImplemented();
  EXPECT_TRUE(called);
}

TEST() [88/363]

flutter::TEST	(	MethodChannelTest	,
		Registration
	)

Definition at line 62 of file method_channel_unittests.cc.

                                      {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  MethodChannel channel(&messenger, channel_name, &codec);
 
  bool callback_called = false;
  const std::string method_name("hello");
  channel.SetMethodCallHandler(
      [&callback_called, method_name](const auto& call, auto result) {
        callback_called = true;
        // Ensure that the wrapper received a correctly decoded call and a
        // result.
        EXPECT_EQ(call.method_name(), method_name);
        EXPECT_NE(result, nullptr);
        result->Success();
      });
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
  // Send a test message to trigger the handler test assertions.
  MethodCall<> call(method_name, nullptr);
  auto message = codec.EncodeMethodCall(call);
 
  messenger.last_message_handler()(
      message->data(), message->size(),
      [](const uint8_t* reply, size_t reply_size) {});
  EXPECT_TRUE(callback_called);
}

TEST() [89/363]

flutter::TEST	(	MethodChannelTest	,
		Resize
	)

Definition at line 167 of file method_channel_unittests.cc.

                                {
  TestBinaryMessenger messenger;
  const std::string channel_name("flutter/test");
  MethodChannel channel(&messenger, channel_name,
                        &StandardMethodCodec::GetInstance());
 
  channel.Resize(3);
 
  // Because the Dart implementation for the control channel implements its own
  // custom deserialization logic, this test compares the generated bytes array
  // to the expected one (for instance, the deserialization logic expects the
  // size parameter of the resize method call to be an uint32).
  //
  // The expected content was created from the following Dart code:
  //   MethodCall call = MethodCall('resize', ['flutter/test',3]);
  //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
  const int expected_message_size = 29;
 
  EXPECT_EQ(messenger.send_called(), true);
  EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
            expected_message_size);
 
  int expected[expected_message_size] = {
      7,   6,   114, 101, 115, 105, 122, 101, 12,  2, 7, 12, 102, 108, 117,
      116, 116, 101, 114, 47,  116, 101, 115, 116, 3, 3, 0,  0,   0};
  for (int i = 0; i < expected_message_size; i++) {
    EXPECT_EQ(messenger.last_message()[i], expected[i]);
  }
}

TEST() [90/363]

flutter::TEST	(	MethodChannelTest	,
		SetWarnsOnOverflow
	)

Definition at line 199 of file method_channel_unittests.cc.

                                            {
  TestBinaryMessenger messenger;
 
  const std::string channel_name("flutter/test");
  MethodChannel channel(&messenger, channel_name,
                        &StandardMethodCodec::GetInstance());
 
  channel.SetWarnsOnOverflow(false);
 
  // The expected content was created from the following Dart code:
  //   MethodCall call = MethodCall('overflow',['flutter/test', true]);
  //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
  const int expected_message_size = 27;
 
  EXPECT_EQ(messenger.send_called(), true);
  EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
            expected_message_size);
 
  int expected[expected_message_size] = {
      7,   8,   111, 118, 101, 114, 102, 108, 111, 119, 12,  2,   7, 12,
      102, 108, 117, 116, 116, 101, 114, 47,  116, 101, 115, 116, 1};
  for (int i = 0; i < expected_message_size; i++) {
    EXPECT_EQ(messenger.last_message()[i], expected[i]);
  }
}

TEST() [91/363]

flutter::TEST	(	MethodChannelTest	,
		Success
	)

Definition at line 23 of file method_result_functions_unittests.cc.

                                 {
  bool called = false;
  int value = 1;
  MethodResultFunctions<int> result(
      [&called, value](const int* i) {
        called = true;
        EXPECT_EQ(*i, value);
      },
      nullptr, nullptr);
  result.Success(value);
  EXPECT_TRUE(called);
}

TEST() [92/363]

flutter::TEST	(	MethodChannelTest	,
		Unregistration
	)

Definition at line 92 of file method_channel_unittests.cc.

                                        {
  TestBinaryMessenger messenger;
  const std::string channel_name("some_channel");
  MethodChannel channel(&messenger, channel_name,
                        &StandardMethodCodec::GetInstance());
 
  channel.SetMethodCallHandler([](const auto& call, auto result) {});
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_NE(messenger.last_message_handler(), nullptr);
 
  channel.SetMethodCallHandler(nullptr);
  EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
  EXPECT_EQ(messenger.last_message_handler(), nullptr);
}

TEST() [93/363]

flutter::TEST	(	PathUtilsTest	,
		ExecutableDirector
	)

Definition at line 12 of file path_utils_unittests.cc.

                                        {
  std::filesystem::path exe_directory = GetExecutableDirectory();
#if defined(__linux__) || defined(_WIN32)
  EXPECT_EQ(exe_directory.empty(), false);
  EXPECT_EQ(exe_directory.is_absolute(), true);
#else
  // On platforms where it's not implemented, it should indicate that
  // by returning an empty path.
  EXPECT_EQ(exe_directory.empty(), true);
#endif
}

TEST() [94/363]

flutter::TEST	(	PluginRegistrarGlfwTest	,
		GetView
	)

Definition at line 37 of file plugin_registrar_glfw_unittests.cc.

                                       {
  testing::ScopedStubFlutterGlfwApi scoped_api_stub(
      std::make_unique<testing::StubFlutterGlfwApi>());
  PluginRegistrarGlfw registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
  EXPECT_NE(registrar.window(), nullptr);
}

TEST() [95/363]

flutter::TEST	(	PluginRegistrarGlfwTest	,
		PluginDestroyedBeforeRegistrar
	)

Definition at line 46 of file plugin_registrar_glfw_unittests.cc.

                                                              {
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  bool registrar_valid_at_destruction = false;
  {
    PluginRegistrarGlfw registrar(dummy_registrar_handle);
 
    auto plugin = std::make_unique<TestPlugin>(&registrar,
                                               &registrar_valid_at_destruction);
    registrar.AddPlugin(std::move(plugin));
  }
  EXPECT_TRUE(registrar_valid_at_destruction);
}

TEST() [96/363]

flutter::TEST	(	PluginRegistrarTest	,
		ManagerDifferentInstances
	)

Definition at line 175 of file plugin_registrar_unittests.cc.

                                                     {
  PluginRegistrarManager* manager = PluginRegistrarManager::GetInstance();
  manager->Reset();
 
  testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
 
  auto dummy_registrar_handle_a =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  auto dummy_registrar_handle_b =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(2);
 
  EXPECT_NE(manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle_a),
            manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle_b));
}

TEST() [97/363]

flutter::TEST	(	PluginRegistrarTest	,
		ManagerRemovesOnDestruction
	)

Definition at line 192 of file plugin_registrar_unittests.cc.

                                                       {
  PluginRegistrarManager* manager = PluginRegistrarManager::GetInstance();
  manager->Reset();
 
  testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
  auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
 
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  auto* wrapper =
      manager->GetRegistrar<TestPluginRegistrar>(dummy_registrar_handle);
 
  // Simulate destruction of the reference, and ensure that the wrapper
  // is destroyed.
  EXPECT_NE(test_api->last_destruction_callback_set(), nullptr);
  bool destroyed = false;
  wrapper->SetDestructionCallback([&destroyed]() { destroyed = true; });
  test_api->last_destruction_callback_set()(dummy_registrar_handle);
  EXPECT_EQ(destroyed, true);
 
  // Requesting the wrapper should now create a new object.
  EXPECT_NE(manager->GetRegistrar<TestPluginRegistrar>(dummy_registrar_handle),
            nullptr);
}

TEST() [98/363]

flutter::TEST	(	PluginRegistrarTest	,
		ManagerSameInstance
	)

Definition at line 160 of file plugin_registrar_unittests.cc.

                                               {
  PluginRegistrarManager* manager = PluginRegistrarManager::GetInstance();
  manager->Reset();
 
  testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
 
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
 
  EXPECT_EQ(manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle),
            manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle));
}

TEST() [99/363]

flutter::TEST	(	PluginRegistrarTest	,
		MessengerSend
	)

Definition at line 120 of file plugin_registrar_unittests.cc.

                                         {
  testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
  auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
 
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  PluginRegistrar registrar(dummy_registrar_handle);
  BinaryMessenger* messenger = registrar.messenger();
 
  std::vector<uint8_t> message = {1, 2, 3, 4};
  messenger->Send("some_channel", &message[0], message.size());
  EXPECT_EQ(test_api->last_data_sent(), &message[0]);
}

TEST() [100/363]

flutter::TEST	(	PluginRegistrarTest	,
		MessengerSetMessageHandler
	)

Definition at line 136 of file plugin_registrar_unittests.cc.

                                                      {
  testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
  auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
 
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  PluginRegistrar registrar(dummy_registrar_handle);
  BinaryMessenger* messenger = registrar.messenger();
  const std::string channel_name("foo");
 
  // Register.
  BinaryMessageHandler binary_handler = [](const uint8_t* message,
                                           const size_t message_size,
                                           const BinaryReply& reply) {};
  messenger->SetMessageHandler(channel_name, std::move(binary_handler));
  EXPECT_NE(test_api->last_message_callback_set(), nullptr);
 
  // Unregister.
  messenger->SetMessageHandler(channel_name, nullptr);
  EXPECT_EQ(test_api->last_message_callback_set(), nullptr);
}

TEST() [101/363]

flutter::TEST	(	PluginRegistrarTest	,
		PluginDestroyedBeforeRegistrar
	)

Definition at line 104 of file plugin_registrar_unittests.cc.

                                                          {
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  bool registrar_valid_at_destruction = false;
  {
    PluginRegistrar registrar(dummy_registrar_handle);
 
    auto plugin = std::make_unique<TestPlugin>(&registrar,
                                               &registrar_valid_at_destruction);
    registrar.AddPlugin(std::move(plugin));
  }
  EXPECT_TRUE(registrar_valid_at_destruction);
}

TEST() [102/363]

flutter::TEST	(	PluginRegistrarTest	,
		TextureRegistrarNotNull
	)

Definition at line 218 of file plugin_registrar_unittests.cc.

                                                   {
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  PluginRegistrar registrar(dummy_registrar_handle);
 
  TextureRegistrar* texture_registrar = registrar.texture_registrar();
 
  ASSERT_NE(texture_registrar, nullptr);
}

TEST() [103/363]

flutter::TEST	(	PluginRegistrarWindowsTest	,
		CallsRegisteredDelegates
	)

Definition at line 161 of file plugin_registrar_windows_unittests.cc.

                                                           {
  auto windows_api = std::make_unique<TestWindowsApi>();
  EXPECT_CALL(*windows_api, PluginRegistrarGetView).WillOnce(Return(nullptr));
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(std::move(windows_api));
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  PluginRegistrarWindows registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
 
  HWND dummy_hwnd;
  bool called_a = false;
  WindowProcDelegate delegate_a = [&called_a, &dummy_hwnd](
                                      HWND hwnd, UINT message, WPARAM wparam,
                                      LPARAM lparam) {
    called_a = true;
    EXPECT_EQ(hwnd, dummy_hwnd);
    EXPECT_EQ(message, 2);
    EXPECT_EQ(wparam, 3);
    EXPECT_EQ(lparam, 4);
    return std::optional<LRESULT>();
  };
  bool called_b = false;
  WindowProcDelegate delegate_b = [&called_b](HWND hwnd, UINT message,
                                              WPARAM wparam, LPARAM lparam) {
    called_b = true;
    return std::optional<LRESULT>();
  };
  int id_a = registrar.RegisterTopLevelWindowProcDelegate(delegate_a);
  int id_b = registrar.RegisterTopLevelWindowProcDelegate(delegate_b);
 
  LRESULT result = 0;
  bool handled = test_api->last_registered_delegate()(
      dummy_hwnd, 2, 3, 4, test_api->last_registered_user_data(), &result);
  EXPECT_TRUE(called_a);
  EXPECT_TRUE(called_b);
  EXPECT_FALSE(handled);
}

TEST() [104/363]

flutter::TEST	(	PluginRegistrarWindowsTest	,
		GetView
	)

Definition at line 76 of file plugin_registrar_windows_unittests.cc.

                                          {
  auto windows_api = std::make_unique<TestWindowsApi>();
  EXPECT_CALL(*windows_api, PluginRegistrarGetView)
      .WillOnce(Return(reinterpret_cast<FlutterDesktopViewRef>(1)));
 
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(std::move(windows_api));
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  PluginRegistrarWindows registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
 
  EXPECT_NE(registrar.GetView(), nullptr);
}

TEST() [105/363]

flutter::TEST	(	PluginRegistrarWindowsTest	,
		GetViewById
	)

Definition at line 89 of file plugin_registrar_windows_unittests.cc.

                                              {
  auto windows_api = std::make_unique<TestWindowsApi>();
  EXPECT_CALL(*windows_api, PluginRegistrarGetView)
      .WillRepeatedly(Return(nullptr));
  EXPECT_CALL(*windows_api, PluginRegistrarGetViewById(123))
      .WillOnce(Return(reinterpret_cast<FlutterDesktopViewRef>(1)));
  EXPECT_CALL(*windows_api, PluginRegistrarGetViewById(456))
      .WillOnce(Return(nullptr));
 
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(std::move(windows_api));
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  PluginRegistrarWindows registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
 
  EXPECT_EQ(registrar.GetView(), nullptr);
  EXPECT_NE(registrar.GetViewById(123).get(), nullptr);
  EXPECT_EQ(registrar.GetViewById(456).get(), nullptr);
}

TEST() [106/363]

flutter::TEST	(	PluginRegistrarWindowsTest	,
		PluginDestroyedBeforeRegistrar
	)

Definition at line 109 of file plugin_registrar_windows_unittests.cc.

                                                                 {
  auto windows_api = std::make_unique<TestWindowsApi>();
  EXPECT_CALL(*windows_api, PluginRegistrarGetView)
      .WillRepeatedly(Return(reinterpret_cast<FlutterDesktopViewRef>(1)));
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(std::move(windows_api));
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  PluginRegistrarWindows registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
 
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  bool registrar_valid_at_destruction = false;
  {
    PluginRegistrarWindows registrar(dummy_registrar_handle);
 
    auto plugin = std::make_unique<TestPlugin>(&registrar,
                                               &registrar_valid_at_destruction);
    registrar.AddPlugin(std::move(plugin));
  }
  EXPECT_TRUE(registrar_valid_at_destruction);
}

TEST() [107/363]

flutter::TEST	(	PluginRegistrarWindowsTest	,
		RegisterUnregister
	)

Definition at line 131 of file plugin_registrar_windows_unittests.cc.

                                                     {
  auto windows_api = std::make_unique<TestWindowsApi>();
  EXPECT_CALL(*windows_api, PluginRegistrarGetView).WillOnce(Return(nullptr));
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(std::move(windows_api));
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  PluginRegistrarWindows registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
 
  WindowProcDelegate delegate = [](HWND hwnd, UINT message, WPARAM wparam,
                                   LPARAM lparam) {
    return std::optional<LRESULT>();
  };
  int id_a = registrar.RegisterTopLevelWindowProcDelegate(delegate);
  EXPECT_EQ(test_api->registered_delegate_count(), 1);
  int id_b = registrar.RegisterTopLevelWindowProcDelegate(delegate);
  // All the C++-level delegates are driven by a since C callback, so the
  // registration count should stay the same.
  EXPECT_EQ(test_api->registered_delegate_count(), 1);
 
  // Unregistering one of the two delegates shouldn't cause the underlying C
  // callback to be unregistered.
  registrar.UnregisterTopLevelWindowProcDelegate(id_a);
  EXPECT_EQ(test_api->registered_delegate_count(), 1);
  // Unregistering both should unregister it.
  registrar.UnregisterTopLevelWindowProcDelegate(id_b);
  EXPECT_EQ(test_api->registered_delegate_count(), 0);
 
  EXPECT_NE(id_a, id_b);
}

TEST() [108/363]

flutter::TEST	(	PluginRegistrarWindowsTest	,
		StopsOnceHandled
	)

Definition at line 198 of file plugin_registrar_windows_unittests.cc.

                                                   {
  auto windows_api = std::make_unique<TestWindowsApi>();
  EXPECT_CALL(*windows_api, PluginRegistrarGetView).WillOnce(Return(nullptr));
  testing::ScopedStubFlutterWindowsApi scoped_api_stub(std::move(windows_api));
  auto test_api = static_cast<TestWindowsApi*>(scoped_api_stub.stub());
  PluginRegistrarWindows registrar(
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1));
 
  bool called_a = false;
  WindowProcDelegate delegate_a = [&called_a](HWND hwnd, UINT message,
                                              WPARAM wparam, LPARAM lparam) {
    called_a = true;
    return std::optional<LRESULT>(7);
  };
  bool called_b = false;
  WindowProcDelegate delegate_b = [&called_b](HWND hwnd, UINT message,
                                              WPARAM wparam, LPARAM lparam) {
    called_b = true;
    return std::optional<LRESULT>(7);
  };
  int id_a = registrar.RegisterTopLevelWindowProcDelegate(delegate_a);
  int id_b = registrar.RegisterTopLevelWindowProcDelegate(delegate_b);
 
  HWND dummy_hwnd;
  LRESULT result = 0;
  bool handled = test_api->last_registered_delegate()(
      dummy_hwnd, 2, 3, 4, test_api->last_registered_user_data(), &result);
  // Only one of the delegates should have been called, since each claims to
  // have fully handled the message.
  EXPECT_TRUE(called_a || called_b);
  EXPECT_NE(called_a, called_b);
  // The return value should propagate through.
  EXPECT_TRUE(handled);
  EXPECT_EQ(result, 7);
}

TEST() [109/363]

flutter::TEST	(	Point	,
		SetsCoordinates
	)

Definition at line 11 of file geometry_unittests.cc.

                             {
  Point point(-30.0, 42.0);
  EXPECT_DOUBLE_EQ(-30.0, point.x());
  EXPECT_DOUBLE_EQ(42.0, point.y());
}

TEST() [110/363]

flutter::TEST	(	RasterizerTest	,
		create
	)

Definition at line 129 of file rasterizer_unittests.cc.

                             {
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  EXPECT_TRUE(rasterizer != nullptr);
}

TEST() [111/363]

flutter::TEST	(	RasterizerTest	,
		drawEmptyPipeline
	)

Definition at line 151 of file rasterizer_unittests.cc.

                                        {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [112/363]

flutter::TEST	(	RasterizerTest	,
		drawLastLayerTreeWithThreadsMergedExternalViewEmbedderAndEndFrameCalled
	)

Definition at line 408 of file rasterizer_unittests.cc.

                                                                              {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  TaskRunners task_runners("test",
                           fml::MessageLoop::GetCurrent().GetTaskRunner(),
                           fml::MessageLoop::GetCurrent().GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
 
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  auto surface_frame1 = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  auto surface_frame2 = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled())
      .WillRepeatedly(Return(true));
  // Prepare two frames for Draw() and DrawLastLayerTrees().
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame1))))
      .WillOnce(Return(ByMove(std::move(surface_frame2))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
  EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
      .WillRepeatedly(Return(true));
 
  EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
                                                  /*raster_thread_merger=*/_))
      .Times(2);
  EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
                                           /*frame_size=*/SkISize(),
                                           /*device_pixel_ratio=*/2.0))
      .Times(2);
  EXPECT_CALL(*external_view_embedder,
              SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
      .Times(2);
  EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
                                                /*raster_thread_merger=*/_))
      .Times(2);
 
  rasterizer->Setup(std::move(surface));
 
  auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
  auto layer_tree = std::make_unique<LayerTree>(/*root_layer=*/nullptr,
                                                /*frame_size=*/SkISize());
  auto layer_tree_item = std::make_unique<FrameItem>(
      SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                          kDevicePixelRatio),
      CreateFinishedBuildRecorder());
  PipelineProduceResult result =
      pipeline->Produce().Complete(std::move(layer_tree_item));
  EXPECT_TRUE(result.success);
 
  // The Draw() will respectively call BeginFrame(), SubmitFlutterView() and
  // EndFrame() one time.
  ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
  rasterizer->Draw(pipeline);
 
  // The DrawLastLayerTrees() will respectively call BeginFrame(),
  // SubmitFlutterView() and EndFrame() one more time, totally 2 times.
  rasterizer->DrawLastLayerTrees(CreateFinishedBuildRecorder());
}

TEST() [113/363]

flutter::TEST	(	RasterizerTest	,
		drawLayerTreeWithCorrectFrameTimingWhenPipelineIsMoreAvailable
	)

Definition at line 1042 of file rasterizer_unittests.cc.

                                                                     {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
 
  fml::AutoResetWaitableEvent latch;
  std::unique_ptr<Rasterizer> rasterizer;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer = std::make_unique<Rasterizer>(delegate);
    latch.Signal();
  });
  latch.Wait();
 
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled())
      .WillRepeatedly(Return(true));
  ON_CALL(*surface, AcquireFrame(SkISize()))
      .WillByDefault(::testing::Invoke([] {
        SurfaceFrame::FramebufferInfo framebuffer_info;
        framebuffer_info.supports_readback = true;
        return std::make_unique<SurfaceFrame>(
            /*surface=*/
            nullptr, framebuffer_info,
            /*submit_callback=*/
            [](const SurfaceFrame& frame, DlCanvas*) { return true; },
            /*frame_size=*/SkISize::Make(800, 600));
      }));
  ON_CALL(*surface, MakeRenderContextCurrent())
      .WillByDefault(::testing::Invoke(
          [] { return std::make_unique<GLContextDefaultResult>(true); }));
 
  fml::CountDownLatch count_down_latch(2);
  auto first_timestamp = fml::TimePoint::Now();
  auto second_timestamp = first_timestamp + fml::TimeDelta::FromMilliseconds(8);
  std::vector<fml::TimePoint> timestamps = {first_timestamp, second_timestamp};
  int frame_rasterized_count = 0;
  EXPECT_CALL(delegate, OnFrameRasterized(_))
      .Times(2)
      .WillRepeatedly([&](const FrameTiming& frame_timing) {
        EXPECT_EQ(timestamps[frame_rasterized_count],
                  frame_timing.Get(FrameTiming::kVsyncStart));
        EXPECT_EQ(timestamps[frame_rasterized_count],
                  frame_timing.Get(FrameTiming::kBuildStart));
        EXPECT_EQ(timestamps[frame_rasterized_count],
                  frame_timing.Get(FrameTiming::kBuildFinish));
        frame_rasterized_count++;
        count_down_latch.CountDown();
      });
 
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer->Setup(std::move(surface));
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    for (int i = 0; i < 2; i++) {
      auto layer_tree = std::make_unique<LayerTree>(
          /*root_layer=*/nullptr, /*frame_size=*/SkISize());
      auto layer_tree_item = std::make_unique<FrameItem>(
          SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                              kDevicePixelRatio),
          CreateFinishedBuildRecorder(timestamps[i]));
      PipelineProduceResult result =
          pipeline->Produce().Complete(std::move(layer_tree_item));
      EXPECT_TRUE(result.success);
      EXPECT_EQ(result.is_first_item, i == 0);
    }
    // Although we only call 'Rasterizer::Draw' once, it will be called twice
    // finally because there are two items in the pipeline.
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
  });
  count_down_latch.Wait();
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer.reset();
    latch.Signal();
  });
  latch.Wait();
}

TEST() [114/363]

flutter::TEST	(	RasterizerTest	,
		drawMultipleViewsWithExternalViewEmbedder
	)

Definition at line 659 of file rasterizer_unittests.cc.

                                                                {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
  EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
      .WillRepeatedly(Return(false));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(SkISize())).Times(2);
  ON_CALL(*surface, AcquireFrame).WillByDefault([](const SkISize& size) {
    SurfaceFrame::FramebufferInfo framebuffer_info;
    framebuffer_info.supports_readback = true;
    return std::make_unique<SurfaceFrame>(
        /*surface=*/
        nullptr, framebuffer_info,
        /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
        /*frame_size=*/SkISize::Make(800, 600));
  });
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
                                                  /*raster_thread_merger=*/_))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              PrepareFlutterView(/*frame_size=*/SkISize(),
                                 /*device_pixel_ratio=*/1.5))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              SubmitFlutterView(/*flutter_view_id=*/0, _, _, _))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              PrepareFlutterView(/*frame_size=*/SkISize(),
                                 /*device_pixel_ratio=*/2.0))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              SubmitFlutterView(/*flutter_view_id=*/1, _, _, _))
      .Times(1);
  EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
                                                /*raster_thread_merger=*/_))
      .Times(1);
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    std::vector<std::unique_ptr<LayerTreeTask>> tasks;
    tasks.push_back(std::make_unique<LayerTreeTask>(
        0, std::make_unique<LayerTree>(nullptr, SkISize()), 1.5));
    tasks.push_back(std::make_unique<LayerTreeTask>(
        1, std::make_unique<LayerTree>(nullptr, SkISize()), 2.0));
    auto layer_tree_item = std::make_unique<FrameItem>(
        std::move(tasks), CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [115/363]

flutter::TEST	(	RasterizerTest	,
		drawWithExternalViewEmbedderAndThreadMergerNotMergedExternalViewEmbedderSubmitFrameNotCalled
	)

Definition at line 259 of file rasterizer_unittests.cc.

                                                                                                  {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
  EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
      .WillRepeatedly(Return(true));
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
                                                  /*raster_thread_merger=*/_))
      .Times(1);
  EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
                                           /*frame_size=*/SkISize(),
                                           /*device_pixel_ratio=*/2.0))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
      .Times(0);
  EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
                                                /*raster_thread_merger=*/_))
      .Times(1);
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [116/363]

flutter::TEST	(	RasterizerTest	,
		drawWithExternalViewEmbedderAndThreadsMergedExternalViewEmbedderSubmitFrameCalled
	)

Definition at line 332 of file rasterizer_unittests.cc.

                                                                                       {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  TaskRunners task_runners("test",
                           fml::MessageLoop::GetCurrent().GetTaskRunner(),
                           fml::MessageLoop::GetCurrent().GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
 
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
  EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
      .WillRepeatedly(Return(true));
 
  EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
                                                  /*raster_thread_merger=*/_))
      .Times(1);
  EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
                                           /*frame_size=*/SkISize(),
                                           /*device_pixel_ratio=*/2.0))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
      .Times(1);
  EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
                                                /*raster_thread_merger=*/_))
      .Times(1);
 
  rasterizer->Setup(std::move(surface));
 
  auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
  auto layer_tree = std::make_unique<LayerTree>(/*root_layer=*/nullptr,
                                                /*frame_size=*/SkISize());
  auto layer_tree_item = std::make_unique<FrameItem>(
      SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                          kDevicePixelRatio),
      CreateFinishedBuildRecorder());
  PipelineProduceResult result =
      pipeline->Produce().Complete(std::move(layer_tree_item));
  EXPECT_TRUE(result.success);
  ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
  rasterizer->Draw(pipeline);
}

TEST() [117/363]

flutter::TEST	(	RasterizerTest	,
		drawWithExternalViewEmbedderExternalViewEmbedderSubmitFrameCalled
	)

Definition at line 181 of file rasterizer_unittests.cc.

                                                                        {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
 
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  EXPECT_CALL(*external_view_embedder,
              BeginFrame(/*context=*/nullptr,
                         /*raster_thread_merger=*/
                         fml::RefPtr<fml::RasterThreadMerger>(nullptr)))
      .Times(1);
  EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
                                           /*frame_size=*/SkISize(),
                                           /*device_pixel_ratio=*/2.0))
      .Times(1);
  EXPECT_CALL(*external_view_embedder,
              SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
      .Times(1);
  EXPECT_CALL(
      *external_view_embedder,
      EndFrame(/*should_resubmit_frame=*/false,
               /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
                   nullptr)))
      .Times(1);
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(/*root_layer=*/nullptr,
                                                  /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [118/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuDisabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame
	)

Definition at line 799 of file rasterizer_unittests.cc.

                                                                               {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  auto is_gpu_disabled_sync_switch =
      std::make_shared<const fml::SyncSwitch>(true);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillByDefault(Return(is_gpu_disabled_sync_switch));
  EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch()).Times(0);
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    DrawStatus status = rasterizer->Draw(pipeline);
    EXPECT_EQ(status, DrawStatus::kDone);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [119/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuDisabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesntAcquireFrame
	)

Definition at line 922 of file rasterizer_unittests.cc.

                                                                                    {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_)).Times(0);
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  auto is_gpu_disabled_sync_switch =
      std::make_shared<const fml::SyncSwitch>(true);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(false));
  EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillOnce(Return(is_gpu_disabled_sync_switch));
  EXPECT_CALL(*surface, AcquireFrame(SkISize())).Times(0);
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    DrawStatus status = rasterizer->Draw(pipeline);
    EXPECT_EQ(status, DrawStatus::kGpuUnavailable);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [120/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuEnabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame
	)

Definition at line 739 of file rasterizer_unittests.cc.

                                                                               {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  auto is_gpu_disabled_sync_switch =
      std::make_shared<const fml::SyncSwitch>(false);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillByDefault(Return(is_gpu_disabled_sync_switch));
  EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch()).Times(0);
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [121/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuEnabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesAcquireFrame
	)

Definition at line 861 of file rasterizer_unittests.cc.

                                                                                 {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  auto is_gpu_disabled_sync_switch =
      std::make_shared<const fml::SyncSwitch>(false);
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, /*framebuffer_info=*/framebuffer_info,
      /*submit_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(false));
  EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillOnce(Return(is_gpu_disabled_sync_switch));
  EXPECT_CALL(*surface, AcquireFrame(SkISize()))
      .WillOnce(Return(ByMove(std::move(surface_frame))));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    DrawStatus status = rasterizer->Draw(pipeline);
    EXPECT_EQ(status, DrawStatus::kDone);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [122/363]

flutter::TEST	(	RasterizerTest	,
		externalViewEmbedderDoesntEndFrameWhenNoSurfaceIsSet
	)

Definition at line 498 of file rasterizer_unittests.cc.

                                                                           {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
 
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
 
  EXPECT_CALL(
      *external_view_embedder,
      EndFrame(/*should_resubmit_frame=*/false,
               /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
                   nullptr)))
      .Times(0);
 
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [123/363]

flutter::TEST	(	RasterizerTest	,
		externalViewEmbedderDoesntEndFrameWhenNotUsedThisFrame
	)

Definition at line 546 of file rasterizer_unittests.cc.

                                                                             {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  auto is_gpu_disabled_sync_switch =
      std::make_shared<const fml::SyncSwitch>(false);
  ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillByDefault(Return(is_gpu_disabled_sync_switch));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
  rasterizer->Setup(std::move(surface));
 
  EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
                                                  /*raster_thread_merger=*/_))
      .Times(0);
  EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
                                           /*frame_size=*/SkISize(),
                                           /*device_pixel_ratio=*/2.0))
      .Times(0);
  EXPECT_CALL(
      *external_view_embedder,
      EndFrame(/*should_resubmit_frame=*/false,
               /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
                   nullptr)))
      .Times(0);
 
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    // Always discard the layer tree.
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(true));
    DrawStatus status = rasterizer->Draw(pipeline);
    EXPECT_EQ(status, DrawStatus::kDone);
    EXPECT_EQ(rasterizer->GetLastDrawStatus(kImplicitViewId),
              DrawSurfaceStatus::kDiscarded);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [124/363]

flutter::TEST	(	RasterizerTest	,
		externalViewEmbedderDoesntEndFrameWhenPipelineIsEmpty
	)

Definition at line 614 of file rasterizer_unittests.cc.

                                                                            {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
 
  std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
      std::make_shared<NiceMock<MockExternalViewEmbedder>>();
  rasterizer->SetExternalViewEmbedder(external_view_embedder);
  rasterizer->Setup(std::move(surface));
 
  EXPECT_CALL(
      *external_view_embedder,
      EndFrame(/*should_resubmit_frame=*/false,
               /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
                   nullptr)))
      .Times(0);
 
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    DrawStatus status = rasterizer->Draw(pipeline);
    EXPECT_EQ(status, DrawStatus::kPipelineEmpty);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [125/363]

flutter::TEST	(	RasterizerTest	,
		FrameTimingRecorderShouldStartRecordingRasterTimeBeforeSurfaceAcquireFrame
	)

Definition at line 982 of file rasterizer_unittests.cc.

                                                                                {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
  EXPECT_CALL(delegate, OnFrameRasterized(_))
      .WillOnce([&](const FrameTiming& frame_timing) {
        fml::TimePoint now = fml::TimePoint::Now();
        fml::TimePoint raster_start =
            frame_timing.Get(FrameTiming::kRasterStart);
        EXPECT_TRUE(now - raster_start < fml::TimeDelta::FromSecondsF(1));
      });
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  auto is_gpu_disabled_sync_switch =
      std::make_shared<const fml::SyncSwitch>(false);
  ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillByDefault(Return(is_gpu_disabled_sync_switch));
  ON_CALL(*surface, AcquireFrame(SkISize()))
      .WillByDefault(::testing::Invoke([] { return nullptr; }));
  EXPECT_CALL(*surface, AcquireFrame(SkISize()));
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
  rasterizer->Setup(std::move(surface));
  fml::AutoResetWaitableEvent latch;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                            kDevicePixelRatio),
        CreateFinishedBuildRecorder());
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    DrawStatus status = rasterizer->Draw(pipeline);
    EXPECT_EQ(status, DrawStatus::kDone);
    EXPECT_EQ(rasterizer->GetLastDrawStatus(kImplicitViewId),
              DrawSurfaceStatus::kFailed);
    latch.Signal();
  });
  latch.Wait();
}

TEST() [126/363]

flutter::TEST	(	RasterizerTest	,
		presentationTimeNotSetWhenVsyncTargetInPast
	)

Definition at line 1307 of file rasterizer_unittests.cc.

                                                                  {
  GTEST_SKIP() << "eglPresentationTime is disabled due to "
                  "https://github.com/flutter/flutter/issues/112503";
#if false
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
                             ThreadHost::Type::kIo | ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
 
  fml::AutoResetWaitableEvent latch;
  std::unique_ptr<Rasterizer> rasterizer;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer = std::make_unique<Rasterizer>(delegate);
    latch.Signal();
  });
  latch.Wait();
 
  const auto millis_16 = fml::TimeDelta::FromMilliseconds(16);
  const auto first_timestamp = fml::TimePoint::Now() - millis_16;
 
  fml::CountDownLatch submit_latch(1);
  auto surface = std::make_unique<MockSurface>();
  ON_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillByDefault(Return(true));
  ON_CALL(*surface, AcquireFrame(SkISize()))
      .WillByDefault(::testing::Invoke([&] {
        SurfaceFrame::FramebufferInfo framebuffer_info;
        framebuffer_info.supports_readback = true;
        return std::make_unique<SurfaceFrame>(
            /*surface=*/nullptr, framebuffer_info,
            /*submit_callback=*/
            [&](const SurfaceFrame& frame, DlCanvas*) {
              const std::optional<fml::TimePoint> pres_time =
                  frame.submit_info().presentation_time;
              EXPECT_EQ(pres_time, std::nullopt);
              submit_latch.CountDown();
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
      }));
 
  ON_CALL(*surface, MakeRenderContextCurrent())
      .WillByDefault(::testing::Invoke(
          [] { return std::make_unique<GLContextDefaultResult>(true); }));
 
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer->Setup(std::move(surface));
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    auto layer_tree = std::make_unique<LayerTree>(
        /*root_layer=*/nullptr, /*frame_size=*/SkISize());
    auto layer_tree_item = std::make_unique<FrameItem>(
        SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                           kDevicePixelRatio),
        CreateFinishedBuildRecorder(first_timestamp));
    PipelineProduceResult result =
        pipeline->Produce().Complete(std::move(layer_tree_item));
    EXPECT_TRUE(result.success);
    EXPECT_EQ(result.is_first_item, true);
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
  });
 
  submit_latch.Wait();
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer.reset();
    latch.Signal();
  });
  latch.Wait();
#endif  // false
}

TEST() [127/363]

flutter::TEST	(	RasterizerTest	,
		presentationTimeSetWhenVsyncTargetInFuture
	)

Definition at line 1218 of file rasterizer_unittests.cc.

                                                                 {
  GTEST_SKIP() << "eglPresentationTime is disabled due to "
                  "https://github.com/flutter/flutter/issues/112503";
#if false
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
                             ThreadHost::Type::kIo | ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
 
  fml::AutoResetWaitableEvent latch;
  std::unique_ptr<Rasterizer> rasterizer;
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer = std::make_unique<Rasterizer>(delegate);
    latch.Signal();
  });
  latch.Wait();
 
  const auto millis_16 = fml::TimeDelta::FromMilliseconds(16);
  const auto first_timestamp = fml::TimePoint::Now() + millis_16;
  auto second_timestamp = first_timestamp + millis_16;
  std::vector<fml::TimePoint> timestamps = {first_timestamp, second_timestamp};
 
  int frames_submitted = 0;
  fml::CountDownLatch submit_latch(2);
  auto surface = std::make_unique<MockSurface>();
  ON_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillByDefault(Return(true));
  ON_CALL(*surface, AcquireFrame(SkISize()))
      .WillByDefault(::testing::Invoke([&] {
        SurfaceFrame::FramebufferInfo framebuffer_info;
        framebuffer_info.supports_readback = true;
        return std::make_unique<SurfaceFrame>(
            /*surface=*/nullptr, framebuffer_info,
            /*submit_callback=*/
            [&](const SurfaceFrame& frame, DlCanvas*) {
              const auto pres_time = *frame.submit_info().presentation_time;
              const auto diff = pres_time - first_timestamp;
              int num_frames_submitted = frames_submitted++;
              EXPECT_EQ(diff.ToMilliseconds(),
                        num_frames_submitted * millis_16.ToMilliseconds());
              submit_latch.CountDown();
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
      }));
 
  ON_CALL(*surface, MakeRenderContextCurrent())
      .WillByDefault(::testing::Invoke(
          [] { return std::make_unique<GLContextDefaultResult>(true); }));
 
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer->Setup(std::move(surface));
    auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
    for (int i = 0; i < 2; i++) {
      auto layer_tree = std::make_unique<LayerTree>(
          /*root_layer=*/nullptr, /*frame_size=*/SkISize());
      auto layer_tree_item = std::make_unique<FrameItem>(
          SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
                             kDevicePixelRatio),
          CreateFinishedBuildRecorder(timestamps[i]));
      PipelineProduceResult result =
          pipeline->Produce().Complete(std::move(layer_tree_item));
      EXPECT_TRUE(result.success);
      EXPECT_EQ(result.is_first_item, i == 0);
    }
    // Although we only call 'Rasterizer::Draw' once, it will be called twice
    // finally because there are two items in the pipeline.
    ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
    rasterizer->Draw(pipeline);
  });
 
  submit_latch.Wait();
  thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
    rasterizer.reset();
    latch.Signal();
  });
  latch.Wait();
#endif  // false
}

TEST() [128/363]

flutter::TEST	(	RasterizerTest	,
		TeardownFreesResourceCache
	)

Definition at line 1131 of file rasterizer_unittests.cc.

                                                 {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
  auto surface = std::make_unique<NiceMock<MockSurface>>();
  auto context = GrDirectContext::MakeMock(nullptr);
  context->setResourceCacheLimit(0);
 
  EXPECT_CALL(*surface, MakeRenderContextCurrent())
      .WillRepeatedly([]() -> std::unique_ptr<GLContextResult> {
        return std::make_unique<GLContextDefaultResult>(true);
      });
  EXPECT_CALL(*surface, GetContext()).WillRepeatedly(Return(context.get()));
 
  rasterizer->Setup(std::move(surface));
  EXPECT_EQ(context->getResourceCacheLimit(), 0ul);
 
  rasterizer->SetResourceCacheMaxBytes(10000000, false);
  EXPECT_EQ(context->getResourceCacheLimit(), 10000000ul);
  EXPECT_EQ(context->getResourceCachePurgeableBytes(), 0ul);
 
  int count = 0;
  size_t bytes = 0;
  context->getResourceCacheUsage(&count, &bytes);
  EXPECT_EQ(bytes, 0ul);
 
  auto image_info =
      SkImageInfo::MakeN32Premul(500, 500, SkColorSpace::MakeSRGB());
  auto sk_surface = SkSurfaces::RenderTarget(context.get(),
                                             skgpu::Budgeted::kYes, image_info);
  EXPECT_TRUE(sk_surface);
 
  SkPaint paint;
  sk_surface->getCanvas()->drawPaint(paint);
  context->flushAndSubmit(GrSyncCpu::kYes);
 
  EXPECT_EQ(context->getResourceCachePurgeableBytes(), 0ul);
 
  sk_surface.reset();
 
  context->getResourceCacheUsage(&count, &bytes);
  EXPECT_GT(bytes, 0ul);
  EXPECT_GT(context->getResourceCachePurgeableBytes(), 0ul);
 
  rasterizer->Teardown();
  EXPECT_EQ(context->getResourceCachePurgeableBytes(), 0ul);
}

TEST() [129/363]

flutter::TEST	(	RasterizerTest	,
		TeardownNoSurface
	)

Definition at line 1194 of file rasterizer_unittests.cc.

                                        {
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  ThreadHost thread_host("io.flutter.test." + test_name + ".",
                         ThreadHost::Type::kPlatform |
                             ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
 
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  EXPECT_CALL(delegate, GetTaskRunners())
      .WillRepeatedly(ReturnRef(task_runners));
 
  auto rasterizer = std::make_unique<Rasterizer>(delegate);
 
  EXPECT_TRUE(rasterizer);
  rasterizer->Teardown();
}

TEST() [130/363]

flutter::TEST	(	Rect	,
		ReturnsLTRB
	)

Definition at line 37 of file geometry_unittests.cc.

                        {
  Point origin(-30.0, 42.0);
  Size size(20.0, 22.0);
  Rect rect(origin, size);
  EXPECT_DOUBLE_EQ(-30.0, rect.left());
  EXPECT_DOUBLE_EQ(42.0, rect.top());
  EXPECT_DOUBLE_EQ(-10.0, rect.right());
  EXPECT_DOUBLE_EQ(64.0, rect.bottom());
}

TEST() [131/363]

flutter::TEST	(	Rect	,
		ReturnsWidthHeight
	)

Definition at line 47 of file geometry_unittests.cc.

                               {
  Point origin(-30.0, 42.0);
  Size size(20.0, 22.0);
  Rect rect(origin, size);
  EXPECT_DOUBLE_EQ(20.0, rect.width());
  EXPECT_DOUBLE_EQ(22.0, rect.height());
}

TEST() [132/363]

flutter::TEST	(	Rect	,
		SetsOriginAndSize
	)

Definition at line 29 of file geometry_unittests.cc.

                              {
  Point origin(-30.0, 42.0);
  Size size(20.0, 22.0);
  Rect rect(origin, size);
  EXPECT_EQ(origin, rect.origin());
  EXPECT_EQ(size, rect.size());
}

TEST() [133/363]

flutter::TEST	(	SamplingProfilerTest	,
		DeleteAfterStart
	)

Definition at line 43 of file sampling_profiler_unittest.cc.

                                             {
  auto thread =
      std::make_unique<fml::Thread>(flutter::testing::GetCurrentTestName());
  auto task_runner = fml::MockTaskRunner::Create();
  std::atomic<int> invoke_count = 0;
 
  // Ignore calls to PostTask since that would require mocking out calls to
  // Dart.
  EXPECT_CALL(*task_runner, PostDelayedTask(_, _))
      .WillRepeatedly(
          Invoke([&](const fml::closure& task, fml::TimeDelta delay) {
            invoke_count.fetch_add(1);
            thread->GetTaskRunner()->PostTask(task);
          }));
 
  {
    auto profiler = SamplingProfiler(
        "profiler",
        /*profiler_task_runner=*/task_runner, [] { return ProfileSample(); },
        /*num_samples_per_sec=*/1000);
    profiler.Start();
  }
  int invoke_count_at_delete = invoke_count.load();
  std::this_thread::sleep_for(std::chrono::milliseconds(2));  // nyquist
  ASSERT_EQ(invoke_count_at_delete, invoke_count.load());
}

TEST() [134/363]

flutter::TEST	(	Size	,
		ClampsDimensionsPositive
	)

Definition at line 23 of file geometry_unittests.cc.

                                     {
  Size size(-20.0, -42.0);
  EXPECT_DOUBLE_EQ(0.0, size.width());
  EXPECT_DOUBLE_EQ(0.0, size.height());
}

TEST() [135/363]

flutter::TEST	(	Size	,
		SetsDimensions
	)

Definition at line 17 of file geometry_unittests.cc.

                           {
  Size size(20.0, 42.0);
  EXPECT_DOUBLE_EQ(20.0, size.width());
  EXPECT_DOUBLE_EQ(42.0, size.height());
}

TEST() [136/363]

flutter::TEST	(	StandardMessageCodec	,
		CanDecodeEmptyBytesAsNullWithoutCallingSerializer
	)

Definition at line 95 of file standard_message_codec_unittests.cc.

                                                                              {
  std::vector<uint8_t> bytes = {};
  const MockStandardCodecSerializer serializer;
  const StandardMessageCodec& codec =
      StandardMessageCodec::GetInstance(&serializer);
 
  auto decoded = codec.DecodeMessage(bytes);
 
  EXPECT_EQ(EncodableValue(), *decoded);
  EXPECT_CALL(serializer, ReadValueOfType(::testing::_, ::testing::_)).Times(0);
}

TEST() [137/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeByteArray
	)

Definition at line 193 of file standard_message_codec_unittests.cc.

                                                        {
  std::vector<uint8_t> bytes = {0x08, 0x04, 0xba, 0x5e, 0xba, 0x11};
  EncodableValue value(std::vector<uint8_t>{0xba, 0x5e, 0xba, 0x11});
  CheckEncodeDecode(value, bytes);
}

TEST() [138/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeDouble
	)

Definition at line 128 of file standard_message_codec_unittests.cc.

                                                     {
  std::vector<uint8_t> bytes = {0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40};
  CheckEncodeDecode(EncodableValue(3.14159265358979311599796346854), bytes);
}

TEST() [139/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeEmptyList
	)

Definition at line 175 of file standard_message_codec_unittests.cc.

                                                        {
  std::vector<uint8_t> bytes = {0x0c, 0x00};
  CheckEncodeDecode(EncodableValue(EncodableList{}), bytes);
}

TEST() [140/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeEmptyString
	)

Definition at line 150 of file standard_message_codec_unittests.cc.

                                                          {
  std::vector<uint8_t> bytes = {0x07, 0x00};
  CheckEncodeDecode(EncodableValue(u8""), bytes);
}

TEST() [141/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeFalse
	)

Definition at line 112 of file standard_message_codec_unittests.cc.

                                                    {
  std::vector<uint8_t> bytes = {0x02};
  CheckEncodeDecode(EncodableValue(false), bytes);
}

TEST() [142/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeFloat32Array
	)

Definition at line 214 of file standard_message_codec_unittests.cc.

                                                           {
  std::vector<uint8_t> bytes = {0x0e, 0x02, 0x00, 0x00, 0xd8, 0x0f,
                                0x49, 0x40, 0x00, 0x00, 0x7a, 0x44};
  EncodableValue value(std::vector<float>{3.1415920257568359375f, 1000.0f});
  CheckEncodeDecode(value, bytes);
}

TEST() [143/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeFloat64Array
	)

Definition at line 221 of file standard_message_codec_unittests.cc.

                                                           {
  std::vector<uint8_t> bytes = {0x0b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40,
                                0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x8f, 0x40};
  EncodableValue value(
      std::vector<double>{3.14159265358979311599796346854, 1000.0});
  CheckEncodeDecode(value, bytes);
}

TEST() [144/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeInt32
	)

Definition at line 117 of file standard_message_codec_unittests.cc.

                                                    {
  std::vector<uint8_t> bytes = {0x03, 0x78, 0x56, 0x34, 0x12};
  CheckEncodeDecode(EncodableValue(0x12345678), bytes);
}

TEST() [145/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeInt32Array
	)

Definition at line 199 of file standard_message_codec_unittests.cc.

                                                         {
  std::vector<uint8_t> bytes = {0x09, 0x03, 0x00, 0x00, 0x78, 0x56, 0x34, 0x12,
                                0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00};
  EncodableValue value(std::vector<int32_t>{0x12345678, -1, 0});
  CheckEncodeDecode(value, bytes);
}

TEST() [146/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeInt64
	)

Definition at line 122 of file standard_message_codec_unittests.cc.

                                                    {
  std::vector<uint8_t> bytes = {0x04, 0xef, 0xcd, 0xab, 0x90,
                                0x78, 0x56, 0x34, 0x12};
  CheckEncodeDecode(EncodableValue(INT64_C(0x1234567890abcdef)), bytes);
}

TEST() [147/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeInt64Array
	)

Definition at line 206 of file standard_message_codec_unittests.cc.

                                                         {
  std::vector<uint8_t> bytes = {0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12,
                                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  EncodableValue value(std::vector<int64_t>{0x1234567890abcdef, -1});
  CheckEncodeDecode(value, bytes);
}

TEST() [148/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeList
	)

Definition at line 155 of file standard_message_codec_unittests.cc.

                                                   {
  std::vector<uint8_t> bytes = {
      0x0c, 0x05, 0x00, 0x07, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x06,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x85, 0xeb, 0x51, 0xb8, 0x1e,
      0x09, 0x40, 0x03, 0x2f, 0x00, 0x00, 0x00, 0x0c, 0x02, 0x03, 0x2a,
      0x00, 0x00, 0x00, 0x07, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64,
  };
  EncodableValue value(EncodableList{
      EncodableValue(),
      EncodableValue("hello"),
      EncodableValue(3.14),
      EncodableValue(47),
      EncodableValue(EncodableList{
          EncodableValue(42),
          EncodableValue("nested"),
      }),
  });
  CheckEncodeDecode(value, bytes);
}

TEST() [149/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeMap
	)

Definition at line 180 of file standard_message_codec_unittests.cc.

                                                  {
  std::vector<uint8_t> bytes_prefix = {0x0d, 0x04};
  EncodableValue value(EncodableMap{
      {EncodableValue("a"), EncodableValue(3.14)},
      {EncodableValue("b"), EncodableValue(47)},
      {EncodableValue(), EncodableValue()},
      {EncodableValue(3.14), EncodableValue(EncodableList{
                                 EncodableValue("nested"),
                             })},
  });
  CheckEncodeDecodeWithEncodePrefix(value, bytes_prefix, 48);
}

TEST() [150/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeNull
	)

Definition at line 90 of file standard_message_codec_unittests.cc.

                                                   {
  std::vector<uint8_t> bytes = {0x00};
  CheckEncodeDecode(EncodableValue(), bytes);
}

TEST() [151/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeSimpleCustomType
	)

Definition at line 230 of file standard_message_codec_unittests.cc.

                                                               {
  std::vector<uint8_t> bytes = {0x80, 0x09, 0x00, 0x00, 0x00,
                                0x10, 0x00, 0x00, 0x00};
  auto point_comparator = [](const EncodableValue& a, const EncodableValue& b) {
    const Point& a_point =
        std::any_cast<Point>(std::get<CustomEncodableValue>(a));
    const Point& b_point =
        std::any_cast<Point>(std::get<CustomEncodableValue>(b));
    return a_point == b_point;
  };
  CheckEncodeDecode(CustomEncodableValue(Point(9, 16)), bytes,
                    &PointExtensionSerializer::GetInstance(), point_comparator);
}

TEST() [152/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeString
	)

Definition at line 134 of file standard_message_codec_unittests.cc.

                                                     {
  std::vector<uint8_t> bytes = {0x07, 0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f,
                                0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64};
  CheckEncodeDecode(EncodableValue(u8"hello world"), bytes);
}

TEST() [153/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeStringWithNonAsciiCodePoint
	)

Definition at line 140 of file standard_message_codec_unittests.cc.

                                                                          {
  std::vector<uint8_t> bytes = {0x07, 0x05, 0x68, 0xe2, 0x98, 0xba, 0x77};
  CheckEncodeDecode(EncodableValue(u8"h\u263Aw"), bytes);
}

TEST() [154/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeStringWithNonBMPCodePoint
	)

Definition at line 145 of file standard_message_codec_unittests.cc.

                                                                        {
  std::vector<uint8_t> bytes = {0x07, 0x06, 0x68, 0xf0, 0x9f, 0x98, 0x82, 0x77};
  CheckEncodeDecode(EncodableValue(u8"h\U0001F602w"), bytes);
}

TEST() [155/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeTrue
	)

Definition at line 107 of file standard_message_codec_unittests.cc.

                                                   {
  std::vector<uint8_t> bytes = {0x01};
  CheckEncodeDecode(EncodableValue(true), bytes);
}

TEST() [156/363]

flutter::TEST	(	StandardMessageCodec	,
		CanEncodeAndDecodeVariableLengthCustomType
	)

Definition at line 244 of file standard_message_codec_unittests.cc.

                                                                       {
  std::vector<uint8_t> bytes = {
      0x81,                                      // custom type
      0x06, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,  // data
      0x07, 0x04,                                // string type and length
      0x74, 0x65, 0x73, 0x74                     // string characters
  };
  auto some_data_comparator = [](const EncodableValue& a,
                                 const EncodableValue& b) {
    const SomeData& data_a =
        std::any_cast<SomeData>(std::get<CustomEncodableValue>(a));
    const SomeData& data_b =
        std::any_cast<SomeData>(std::get<CustomEncodableValue>(b));
    return data_a.data() == data_b.data() && data_a.label() == data_b.label();
  };
  CheckEncodeDecode(CustomEncodableValue(
                        SomeData("test", {0x00, 0x01, 0x02, 0x03, 0x04, 0x05})),
                    bytes, &SomeDataExtensionSerializer::GetInstance(),
                    some_data_comparator);
}

TEST() [157/363]

flutter::TEST	(	StandardMessageCodec	,
		GetInstanceCachesInstance
	)

Definition at line 82 of file standard_message_codec_unittests.cc.

                                                      {
  const StandardMessageCodec& codec_a =
      StandardMessageCodec::GetInstance(nullptr);
  const StandardMessageCodec& codec_b =
      StandardMessageCodec::GetInstance(nullptr);
  EXPECT_EQ(&codec_a, &codec_b);
}

TEST() [158/363]

flutter::TEST	(	StandardMethodCodec	,
		GetInstanceCachesInstance
	)

Definition at line 35 of file standard_method_codec_unittests.cc.

                                                     {
  const StandardMethodCodec& codec_a =
      StandardMethodCodec::GetInstance(nullptr);
  const StandardMethodCodec& codec_b =
      StandardMethodCodec::GetInstance(nullptr);
  EXPECT_EQ(&codec_a, &codec_b);
}

TEST() [159/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesCustomTypeArguments
	)

Definition at line 167 of file standard_method_codec_unittests.cc.

                                                      {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance(
      &PointExtensionSerializer::GetInstance());
  Point point(7, 9);
  MethodCall<> call(
      "hello", std::make_unique<EncodableValue>(CustomEncodableValue(point)));
  auto encoded = codec.EncodeMethodCall(call);
  ASSERT_NE(encoded.get(), nullptr);
  std::unique_ptr<MethodCall<>> decoded = codec.DecodeMethodCall(*encoded);
  ASSERT_NE(decoded.get(), nullptr);
 
  const Point& decoded_point = std::any_cast<Point>(
      std::get<CustomEncodableValue>(*decoded->arguments()));
  EXPECT_EQ(point, decoded_point);
};

TEST() [160/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesErrorEnvelopesWithDetails
	)

Definition at line 130 of file standard_method_codec_unittests.cc.

                                                            {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EncodableValue details(EncodableList{
      EncodableValue("a"),
      EncodableValue(42),
  });
  auto encoded =
      codec.EncodeErrorEnvelope("errorCode", "something failed", &details);
  ASSERT_NE(encoded.get(), nullptr);
  std::vector<uint8_t> bytes = {
      0x01, 0x07, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f,
      0x64, 0x65, 0x07, 0x10, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68,
      0x69, 0x6e, 0x67, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64,
      0x0c, 0x02, 0x07, 0x01, 0x61, 0x03, 0x2a, 0x00, 0x00, 0x00,
  };
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<> result_handler(
      nullptr,
      [&decoded_successfully](const std::string& code,
                              const std::string& message,
                              const EncodableValue* details) {
        decoded_successfully = true;
        EXPECT_EQ(code, "errorCode");
        EXPECT_EQ(message, "something failed");
        const auto* details_list = std::get_if<EncodableList>(details);
        ASSERT_NE(details_list, nullptr);
        EXPECT_EQ(std::get<std::string>((*details_list)[0]), "a");
        EXPECT_EQ(std::get<int32_t>((*details_list)[1]), 42);
      },
      nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [161/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesErrorEnvelopesWithNulls
	)

Definition at line 105 of file standard_method_codec_unittests.cc.

                                                          {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  auto encoded = codec.EncodeErrorEnvelope("errorCode");
  ASSERT_NE(encoded.get(), nullptr);
  std::vector<uint8_t> bytes = {0x01, 0x07, 0x09, 0x65, 0x72, 0x72, 0x6f,
                                0x72, 0x43, 0x6f, 0x64, 0x65, 0x00, 0x00};
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<> result_handler(
      nullptr,
      [&decoded_successfully](const std::string& code,
                              const std::string& message,
                              const EncodableValue* details) {
        decoded_successfully = true;
        EXPECT_EQ(code, "errorCode");
        EXPECT_EQ(message, "");
        EXPECT_EQ(details, nullptr);
      },
      nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [162/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesMethodCallsWithArgument
	)

Definition at line 53 of file standard_method_codec_unittests.cc.

                                                          {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  MethodCall<> call("hello", std::make_unique<EncodableValue>(EncodableList{
                                 EncodableValue(42),
                                 EncodableValue("world"),
                             }));
  auto encoded = codec.EncodeMethodCall(call);
  ASSERT_NE(encoded.get(), nullptr);
  std::unique_ptr<MethodCall<>> decoded = codec.DecodeMethodCall(*encoded);
  ASSERT_NE(decoded.get(), nullptr);
  EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
}

TEST() [163/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesMethodCallsWithNullArguments
	)

Definition at line 43 of file standard_method_codec_unittests.cc.

                                                               {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  MethodCall<> call("hello", nullptr);
  auto encoded = codec.EncodeMethodCall(call);
  ASSERT_NE(encoded.get(), nullptr);
  std::unique_ptr<MethodCall<>> decoded = codec.DecodeMethodCall(*encoded);
  ASSERT_NE(decoded.get(), nullptr);
  EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
}

TEST() [164/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesSuccessEnvelopesWithNullResult
	)

Definition at line 66 of file standard_method_codec_unittests.cc.

                                                                 {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  auto encoded = codec.EncodeSuccessEnvelope();
  ASSERT_NE(encoded.get(), nullptr);
  std::vector<uint8_t> bytes = {0x00, 0x00};
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<> result_handler(
      [&decoded_successfully](const EncodableValue* result) {
        decoded_successfully = true;
        EXPECT_EQ(result, nullptr);
      },
      nullptr, nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [165/363]

flutter::TEST	(	StandardMethodCodec	,
		HandlesSuccessEnvelopesWithResult
	)

Definition at line 85 of file standard_method_codec_unittests.cc.

                                                             {
  const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
  EncodableValue result(42);
  auto encoded = codec.EncodeSuccessEnvelope(&result);
  ASSERT_NE(encoded.get(), nullptr);
  std::vector<uint8_t> bytes = {0x00, 0x03, 0x2a, 0x00, 0x00, 0x00};
  EXPECT_EQ(*encoded, bytes);
 
  bool decoded_successfully = false;
  MethodResultFunctions<> result_handler(
      [&decoded_successfully](const EncodableValue* result) {
        decoded_successfully = true;
        EXPECT_EQ(std::get<int32_t>(*result), 42);
      },
      nullptr, nullptr);
  codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
                                         &result_handler);
  EXPECT_TRUE(decoded_successfully);
}

TEST() [166/363]

flutter::TEST	(	TextEditingDeltaTest	,
		TestTextEditingDeltaConstructor
	)

Definition at line 11 of file text_editing_delta_unittests.cc.

                                                            {
  // Here we are simulating inserting an "o" at the end of "hell".
  std::string old_text = "hell";
  std::string replacement_text = "hello";
  TextRange range(0, 4);
 
  TextEditingDelta delta = TextEditingDelta(old_text, range, replacement_text);
 
  EXPECT_EQ(delta.old_text(), old_text);
  EXPECT_EQ(delta.delta_text(), "hello");
  EXPECT_EQ(delta.delta_start(), 0);
  EXPECT_EQ(delta.delta_end(), 4);
}

TEST() [167/363]

flutter::TEST	(	TextEditingDeltaTest	,
		TestTextEditingDeltaNonTextConstructor
	)

Definition at line 25 of file text_editing_delta_unittests.cc.

                                                                   {
  // Here we are simulating inserting an "o" at the end of "hell".
  std::string old_text = "hello";
 
  TextEditingDelta delta = TextEditingDelta(old_text);
 
  EXPECT_EQ(delta.old_text(), old_text);
  EXPECT_EQ(delta.delta_text(), "");
  EXPECT_EQ(delta.delta_start(), -1);
  EXPECT_EQ(delta.delta_end(), -1);
}

TEST() [168/363]

flutter::TEST	(	TextInputModel	,
		AddCodePoint
	)

Definition at line 417 of file text_input_model_unittests.cc.

                                   {
  auto model = std::make_unique<TextInputModel>();
  model->AddCodePoint('A');
  model->AddCodePoint('B');
  model->AddCodePoint(0x1f604);
  model->AddCodePoint('D');
  model->AddCodePoint('E');
  EXPECT_EQ(model->selection(), TextRange(6));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AB😄DE");
}

TEST() [169/363]

flutter::TEST	(	TextInputModel	,
		AddCodePointReverseSelection
	)

Definition at line 439 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  model->AddCodePoint('x');
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AxE");
}

TEST() [170/363]

flutter::TEST	(	TextInputModel	,
		AddCodePointReverseSelectionWideCharacter
	)

Definition at line 459 of file text_input_model_unittests.cc.

                                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  model->AddCodePoint(0x1f604);
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "A😄E");
}

TEST() [171/363]

flutter::TEST	(	TextInputModel	,
		AddCodePointSelection
	)

Definition at line 429 of file text_input_model_unittests.cc.

                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  model->AddCodePoint('x');
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AxE");
}

TEST() [172/363]

flutter::TEST	(	TextInputModel	,
		AddCodePointSelectionWideCharacter
	)

Definition at line 449 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  model->AddCodePoint(0x1f604);
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "A😄E");
}

TEST() [173/363]

flutter::TEST	(	TextInputModel	,
		AddText
	)

Definition at line 469 of file text_input_model_unittests.cc.

                              {
  auto model = std::make_unique<TextInputModel>();
  model->AddText(u"ABCDE");
  model->AddText("😄");
  model->AddText("FGHIJ");
  EXPECT_EQ(model->selection(), TextRange(12));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE😄FGHIJ");
}

TEST() [174/363]

flutter::TEST	(	TextInputModel	,
		AddTextReverseSelection
	)

Definition at line 489 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  model->AddText("xy");
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AxyE");
}

TEST() [175/363]

flutter::TEST	(	TextInputModel	,
		AddTextReverseSelectionWideCharacter
	)

Definition at line 509 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  model->AddText(u"😄🙃");
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "A😄🙃E");
}

TEST() [176/363]

flutter::TEST	(	TextInputModel	,
		AddTextSelection
	)

Definition at line 479 of file text_input_model_unittests.cc.

                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  model->AddText("xy");
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AxyE");
}

TEST() [177/363]

flutter::TEST	(	TextInputModel	,
		AddTextSelectionWideCharacter
	)

Definition at line 499 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  model->AddText(u"😄🙃");
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "A😄🙃E");
}

TEST() [178/363]

flutter::TEST	(	TextInputModel	,
		BackspaceEnd
	)

Definition at line 878 of file text_input_model_unittests.cc.

                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCD");
}

TEST() [179/363]

flutter::TEST	(	TextInputModel	,
		BackspaceEndComposing
	)

Definition at line 962 of file text_input_model_unittests.cc.

                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ABCE");
}

TEST() [180/363]

flutter::TEST	(	TextInputModel	,
		BackspaceEndReverseComposing
	)

Definition at line 973 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(3, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCE");
}

TEST() [181/363]

flutter::TEST	(	TextInputModel	,
		BackspaceMiddle
	)

Definition at line 868 of file text_input_model_unittests.cc.

                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ACDE");
}

TEST() [182/363]

flutter::TEST	(	TextInputModel	,
		BackspaceMiddleComposing
	)

Definition at line 940 of file text_input_model_unittests.cc.

                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ACDE");
}

TEST() [183/363]

flutter::TEST	(	TextInputModel	,
		BackspaceMiddleReverseComposing
	)

Definition at line 951 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(3, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ACDE");
}

TEST() [184/363]

flutter::TEST	(	TextInputModel	,
		BackspaceReverseSelection
	)

Definition at line 908 of file text_input_model_unittests.cc.

                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AE");
}

TEST() [185/363]

flutter::TEST	(	TextInputModel	,
		BackspaceSelection
	)

Definition at line 898 of file text_input_model_unittests.cc.

                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AE");
}

TEST() [186/363]

flutter::TEST	(	TextInputModel	,
		BackspaceStart
	)

Definition at line 858 of file text_input_model_unittests.cc.

                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  ASSERT_FALSE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [187/363]

flutter::TEST	(	TextInputModel	,
		BackspaceStartComposing
	)

Definition at line 918 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  ASSERT_FALSE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [188/363]

flutter::TEST	(	TextInputModel	,
		BackspaceStartReverseComposing
	)

Definition at line 929 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
  ASSERT_FALSE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [189/363]

flutter::TEST	(	TextInputModel	,
		BackspaceWideCharacters
	)

Definition at line 888 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("😄🙃🤪🧐");
  EXPECT_TRUE(model->SetSelection(TextRange(4)));
  ASSERT_TRUE(model->Backspace());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "😄🤪🧐");
}

TEST() [190/363]

flutter::TEST	(	TextInputModel	,
		CommitComposingNoTextWithNoSelection
	)

Definition at line 230 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->SetSelection(TextRange(0));
 
  // Verify no changes on BeginComposing.
  model->BeginComposing();
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
 
  // Verify no changes on CommitComposing.
  model->CommitComposing();
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
 
  // Verify no changes on CommitComposing.
  model->EndComposing();
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [191/363]

flutter::TEST	(	TextInputModel	,
		CommitComposingNoTextWithSelection
	)

Definition at line 255 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->SetSelection(TextRange(1, 3));
 
  // Verify no changes on BeginComposing.
  model->BeginComposing();
  EXPECT_EQ(model->selection(), TextRange(1, 3));
  EXPECT_EQ(model->composing_range(), TextRange(1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
 
  // Verify no changes on CommitComposing.
  model->CommitComposing();
  EXPECT_EQ(model->selection(), TextRange(1, 3));
  EXPECT_EQ(model->composing_range(), TextRange(1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
 
  // Verify no changes on CommitComposing.
  model->EndComposing();
  EXPECT_EQ(model->selection(), TextRange(1, 3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [192/363]

flutter::TEST	(	TextInputModel	,
		CommitComposingTextWithNoSelection
	)

Definition at line 280 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->SetSelection(TextRange(1));
 
  // Verify no changes on BeginComposing.
  model->BeginComposing();
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
 
  // Verify selection base, extent and composing extent increment as text is
  // entered. Verify composing base does not change.
  model->UpdateComposingText("つ");
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "AつBCDE");
  model->UpdateComposingText("つる");
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "AつるBCDE");
 
  // Verify that cursor position is set to correct offset from composing base.
  model->UpdateComposingText("鶴");
  EXPECT_TRUE(model->SetSelection(TextRange(1)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴BCDE");
 
  // Verify composing base is set to composing extent on commit.
  model->CommitComposing();
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(2));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴BCDE");
 
  // Verify that further text entry increments the selection base, extent and
  // the composing extent. Verify that composing base does not change.
  model->UpdateComposingText("が");
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(2, 3));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴がBCDE");
 
  // Verify composing base is set to composing extent on commit.
  model->CommitComposing();
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(3));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴がBCDE");
 
  // Verify no changes on EndComposing.
  model->EndComposing();
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴がBCDE");
}

TEST() [193/363]

flutter::TEST	(	TextInputModel	,
		CommitComposingTextWithSelection
	)

Definition at line 336 of file text_input_model_unittests.cc.

                                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->SetSelection(TextRange(1, 3));
 
  // Verify no changes on BeginComposing.
  model->BeginComposing();
  EXPECT_EQ(model->selection(), TextRange(1, 3));
  EXPECT_EQ(model->composing_range(), TextRange(1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
 
  // Verify selection is replaced and selection base, extent and composing
  // extent increment to the position immediately after the composing text.
  // Verify composing base does not change.
  model->UpdateComposingText("つ");
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "AつDE");
 
  // Verify that further text entry increments the selection base, extent and
  // the composing extent. Verify that composing base does not change.
  model->UpdateComposingText("つる");
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "AつるDE");
 
  // Verify that cursor position is set to correct offset from composing base.
  model->UpdateComposingText("鶴");
  EXPECT_TRUE(model->SetSelection(TextRange(1)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴DE");
 
  // Verify composing base is set to composing extent on commit.
  model->CommitComposing();
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(2));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴DE");
 
  // Verify that further text entry increments the selection base, extent and
  // the composing extent. Verify that composing base does not change.
  model->UpdateComposingText("が");
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(2, 3));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴がDE");
 
  // Verify composing base is set to composing extent on commit.
  model->CommitComposing();
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(3));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴がDE");
 
  // Verify no changes on EndComposing.
  model->EndComposing();
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "A鶴がDE");
}

TEST() [194/363]

flutter::TEST	(	TextInputModel	,
		DeleteEnd
	)

Definition at line 539 of file text_input_model_unittests.cc.

                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  ASSERT_FALSE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [195/363]

flutter::TEST	(	TextInputModel	,
		DeleteEndComposing
	)

Definition at line 627 of file text_input_model_unittests.cc.

                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  ASSERT_FALSE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [196/363]

flutter::TEST	(	TextInputModel	,
		DeleteEndReverseComposing
	)

Definition at line 638 of file text_input_model_unittests.cc.

                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  ASSERT_FALSE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [197/363]

flutter::TEST	(	TextInputModel	,
		DeleteMiddle
	)

Definition at line 529 of file text_input_model_unittests.cc.

                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [198/363]

flutter::TEST	(	TextInputModel	,
		DeleteMiddleComposing
	)

Definition at line 605 of file text_input_model_unittests.cc.

                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [199/363]

flutter::TEST	(	TextInputModel	,
		DeleteMiddleReverseComposing
	)

Definition at line 616 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(3, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [200/363]

flutter::TEST	(	TextInputModel	,
		DeleteReverseSelection
	)

Definition at line 569 of file text_input_model_unittests.cc.

                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AE");
}

TEST() [201/363]

flutter::TEST	(	TextInputModel	,
		DeleteSelection
	)

Definition at line 559 of file text_input_model_unittests.cc.

                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AE");
}

TEST() [202/363]

flutter::TEST	(	TextInputModel	,
		DeleteStart
	)

Definition at line 519 of file text_input_model_unittests.cc.

                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "BCDE");
}

TEST() [203/363]

flutter::TEST	(	TextInputModel	,
		DeleteStartComposing
	)

Definition at line 579 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ACDE");
}

TEST() [204/363]

flutter::TEST	(	TextInputModel	,
		DeleteStartReverseComposing
	)

Definition at line 592 of file text_input_model_unittests.cc.

                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(3, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ACDE");
}

TEST() [205/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAfterCursor
	)

Definition at line 775 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(1, 1));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCE");
}

TEST() [206/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAfterCursorAll
	)

Definition at line 796 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(1, 2));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABC");
}

TEST() [207/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAfterCursorAllComposing
	)

Definition at line 806 of file text_input_model_unittests.cc.

                                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->DeleteSurrounding(1, 2));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "ABE");
}

TEST() [208/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAfterCursorComposing
	)

Definition at line 785 of file text_input_model_unittests.cc.

                                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->DeleteSurrounding(1, 1));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [209/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAfterCursorGreedy
	)

Definition at line 817 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(1, 3));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABC");
}

TEST() [210/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAfterCursorGreedyComposing
	)

Definition at line 827 of file text_input_model_unittests.cc.

                                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->DeleteSurrounding(1, 3));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "ABE");
}

TEST() [211/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAtCursor
	)

Definition at line 649 of file text_input_model_unittests.cc.

                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(0, 1));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [212/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAtCursorAll
	)

Definition at line 670 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(0, 3));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AB");
}

TEST() [213/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAtCursorAllComposing
	)

Definition at line 680 of file text_input_model_unittests.cc.

                                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->DeleteSurrounding(0, 2));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "ABE");
}

TEST() [214/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAtCursorComposing
	)

Definition at line 659 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->DeleteSurrounding(0, 1));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [215/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAtCursorGreedy
	)

Definition at line 691 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(0, 4));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "AB");
}

TEST() [216/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingAtCursorGreedyComposing
	)

Definition at line 701 of file text_input_model_unittests.cc.

                                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->DeleteSurrounding(0, 4));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "ABE");
}

TEST() [217/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingBeforeCursor
	)

Definition at line 712 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(-1, 1));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ACDE");
}

TEST() [218/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingBeforeCursorAll
	)

Definition at line 733 of file text_input_model_unittests.cc.

                                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(-2, 2));
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "CDE");
}

TEST() [219/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingBeforeCursorAllComposing
	)

Definition at line 743 of file text_input_model_unittests.cc.

                                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 2));
  EXPECT_TRUE(model->DeleteSurrounding(-2, 2));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "ADE");
}

TEST() [220/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingBeforeCursorComposing
	)

Definition at line 722 of file text_input_model_unittests.cc.

                                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 2));
  EXPECT_TRUE(model->DeleteSurrounding(-1, 1));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 3));
  EXPECT_STREQ(model->GetText().c_str(), "ABDE");
}

TEST() [221/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingBeforeCursorGreedy
	)

Definition at line 754 of file text_input_model_unittests.cc.

                                                          {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->DeleteSurrounding(-3, 3));
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "CDE");
}

TEST() [222/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingBeforeCursorGreedyComposing
	)

Definition at line 764 of file text_input_model_unittests.cc.

                                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 2));
  EXPECT_TRUE(model->DeleteSurrounding(-3, 3));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 2));
  EXPECT_STREQ(model->GetText().c_str(), "ADE");
}

TEST() [223/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingReverseSelection
	)

Definition at line 848 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 3)));
  EXPECT_TRUE(model->DeleteSurrounding(0, 1));
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCE");
}

TEST() [224/363]

flutter::TEST	(	TextInputModel	,
		DeleteSurroundingSelection
	)

Definition at line 838 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2, 3)));
  EXPECT_TRUE(model->DeleteSurrounding(0, 1));
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCE");
}

TEST() [225/363]

flutter::TEST	(	TextInputModel	,
		DeleteWideCharacters
	)

Definition at line 549 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("😄🙃🤪🧐");
  EXPECT_TRUE(model->SetSelection(TextRange(4)));
  ASSERT_TRUE(model->Delete());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "😄🙃🧐");
}

TEST() [226/363]

flutter::TEST	(	TextInputModel	,
		GetCursorOffset
	)

Definition at line 1702 of file text_input_model_unittests.cc.

                                      {
  auto model = std::make_unique<TextInputModel>();
  // These characters take 1, 2, 3 and 4 bytes in UTF-8.
  model->SetText("$¢€𐍈");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_EQ(model->GetCursorOffset(), 0);
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->GetCursorOffset(), 1);
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->GetCursorOffset(), 3);
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->GetCursorOffset(), 6);
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->GetCursorOffset(), 10);
}

TEST() [227/363]

flutter::TEST	(	TextInputModel	,
		GetCursorOffsetReverseSelection
	)

Definition at line 1725 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_EQ(model->GetCursorOffset(), 1);
}

TEST() [228/363]

flutter::TEST	(	TextInputModel	,
		GetCursorOffsetSelection
	)

Definition at line 1718 of file text_input_model_unittests.cc.

                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_EQ(model->GetCursorOffset(), 4);
}

TEST() [229/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackEnd
	)

Definition at line 1130 of file text_input_model_unittests.cc.

                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [230/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackEndComposing
	)

Definition at line 1216 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [231/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackEndReverseComposing
	)

Definition at line 1227 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [232/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackMiddle
	)

Definition at line 1120 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [233/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackMiddleComposing
	)

Definition at line 1194 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [234/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackMiddleReverseComposing
	)

Definition at line 1205 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [235/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackReverseSelection
	)

Definition at line 1160 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [236/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackSelection
	)

Definition at line 1150 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [237/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackStart
	)

Definition at line 1110 of file text_input_model_unittests.cc.

                                          {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_FALSE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [238/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackStartComposing
	)

Definition at line 1170 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->SetSelection(TextRange(1)));
  EXPECT_FALSE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [239/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackStartReverseComposing
	)

Definition at line 1182 of file text_input_model_unittests.cc.

                                                          {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
  EXPECT_TRUE(model->SetSelection(TextRange(1)));
  EXPECT_FALSE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [240/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorBackWideCharacters
	)

Definition at line 1140 of file text_input_model_unittests.cc.

                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("😄🙃🤪🧐");
  EXPECT_TRUE(model->SetSelection(TextRange(4)));
  ASSERT_TRUE(model->MoveCursorBack());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "😄🙃🤪🧐");
}

TEST() [241/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardEnd
	)

Definition at line 1004 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_FALSE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [242/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardEndComposing
	)

Definition at line 1088 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_FALSE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [243/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardEndReverseComposing
	)

Definition at line 1099 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_FALSE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [244/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardMiddle
	)

Definition at line 994 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [245/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardMiddleComposing
	)

Definition at line 1066 of file text_input_model_unittests.cc.

                                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [246/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardMiddleReverseComposing
	)

Definition at line 1077 of file text_input_model_unittests.cc.

                                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(3));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [247/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardReverseSelection
	)

Definition at line 1034 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [248/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardSelection
	)

Definition at line 1024 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [249/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardStart
	)

Definition at line 984 of file text_input_model_unittests.cc.

                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [250/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardStartComposing
	)

Definition at line 1044 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [251/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardStartReverseComposing
	)

Definition at line 1055 of file text_input_model_unittests.cc.

                                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
  EXPECT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [252/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorForwardWideCharacters
	)

Definition at line 1014 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("😄🙃🤪🧐");
  EXPECT_TRUE(model->SetSelection(TextRange(4)));
  ASSERT_TRUE(model->MoveCursorForward());
  EXPECT_EQ(model->selection(), TextRange(6));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "😄🙃🤪🧐");
}

TEST() [253/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningEnd
	)

Definition at line 1278 of file text_input_model_unittests.cc.

                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [254/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningEndComposing
	)

Definition at line 1426 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [255/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningEndReverseComposing
	)

Definition at line 1448 of file text_input_model_unittests.cc.

                                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [256/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningMiddle
	)

Definition at line 1258 of file text_input_model_unittests.cc.

                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [257/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningMiddleComposing
	)

Definition at line 1382 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [258/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningMiddleReverseComposing
	)

Definition at line 1404 of file text_input_model_unittests.cc.

                                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [259/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningReverseSelection
	)

Definition at line 1318 of file text_input_model_unittests.cc.

                                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [260/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningSelection
	)

Definition at line 1298 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [261/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningStart
	)

Definition at line 1238 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_FALSE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [262/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningStartComposing
	)

Definition at line 1338 of file text_input_model_unittests.cc.

                                                          {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_FALSE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [263/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToBeginningStartReverseComposing
	)

Definition at line 1360 of file text_input_model_unittests.cc.

                                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
  EXPECT_FALSE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [264/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndEnd
	)

Definition at line 1510 of file text_input_model_unittests.cc.

                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_FALSE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [265/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndEndComposing
	)

Definition at line 1658 of file text_input_model_unittests.cc.

                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_FALSE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [266/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndEndReverseComposing
	)

Definition at line 1680 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_FALSE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [267/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndMiddle
	)

Definition at line 1490 of file text_input_model_unittests.cc.

                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [268/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndMiddleComposing
	)

Definition at line 1614 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [269/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndMiddleReverseComposing
	)

Definition at line 1636 of file text_input_model_unittests.cc.

                                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [270/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndReverseSelection
	)

Definition at line 1550 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [271/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndSelection
	)

Definition at line 1530 of file text_input_model_unittests.cc.

                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [272/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndStart
	)

Definition at line 1470 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [273/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndStartComposing
	)

Definition at line 1570 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [274/363]

flutter::TEST	(	TextInputModel	,
		MoveCursorToEndStartReverseComposing
	)

Definition at line 1592 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->MoveCursorToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [275/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningEnd
	)

Definition at line 1288 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(5, 0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [276/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningEndComposing
	)

Definition at line 1437 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_TRUE(model->MoveCursorToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [277/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningEndReverseComposing
	)

Definition at line 1459 of file text_input_model_unittests.cc.

                                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(4, 1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [278/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningMiddle
	)

Definition at line 1268 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(2, 0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [279/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningMiddleComposing
	)

Definition at line 1393 of file text_input_model_unittests.cc.

                                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(2, 1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [280/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningMiddleReverseComposing
	)

Definition at line 1415 of file text_input_model_unittests.cc.

                                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(2, 1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [281/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningReverseSelection
	)

Definition at line 1328 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(4, 0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [282/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningSelection
	)

Definition at line 1308 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_TRUE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1, 0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [283/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningStart
	)

Definition at line 1248 of file text_input_model_unittests.cc.

                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_FALSE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [284/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningStartComposing
	)

Definition at line 1349 of file text_input_model_unittests.cc.

                                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_FALSE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [285/363]

flutter::TEST	(	TextInputModel	,
		SelectToBeginningStartReverseComposing
	)

Definition at line 1371 of file text_input_model_unittests.cc.

                                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
  EXPECT_FALSE(model->SelectToBeginning());
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [286/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndEnd
	)

Definition at line 1520 of file text_input_model_unittests.cc.

                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_FALSE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [287/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndEndComposing
	)

Definition at line 1669 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_FALSE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [288/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndEndReverseComposing
	)

Definition at line 1691 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_FALSE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [289/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndMiddle
	)

Definition at line 1500 of file text_input_model_unittests.cc.

                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(2, 5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [290/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndMiddleComposing
	)

Definition at line 1625 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(2, 4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [291/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndMiddleReverseComposing
	)

Definition at line 1647 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(2, 4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [292/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndReverseSelection
	)

Definition at line 1560 of file text_input_model_unittests.cc.

                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(4, 5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [293/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndSelection
	)

Definition at line 1540 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(1, 5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [294/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndStart
	)

Definition at line 1480 of file text_input_model_unittests.cc.

                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(0, 5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [295/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndStartComposing
	)

Definition at line 1581 of file text_input_model_unittests.cc.

                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(1, 4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [296/363]

flutter::TEST	(	TextInputModel	,
		SelectToEndStartReverseComposing
	)

Definition at line 1603 of file text_input_model_unittests.cc.

                                                       {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->SelectToEnd());
  EXPECT_EQ(model->selection(), TextRange(1, 4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [297/363]

flutter::TEST	(	TextInputModel	,
		SetComposingRangeEnd
	)

Definition at line 190 of file text_input_model_unittests.cc.

                                           {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(5, 5), 0));
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(5));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [298/363]

flutter::TEST	(	TextInputModel	,
		SetComposingRangeMiddle
	)

Definition at line 180 of file text_input_model_unittests.cc.

                                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(2, 2), 0));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(2));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [299/363]

flutter::TEST	(	TextInputModel	,
		SetComposingRangeOutsideString
	)

Definition at line 220 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_FALSE(model->SetComposingRange(TextRange(4, 6), 0));
  EXPECT_FALSE(model->SetComposingRange(TextRange(5, 6), 0));
  EXPECT_FALSE(model->SetComposingRange(TextRange(6, 6), 0));
}

TEST() [300/363]

flutter::TEST	(	TextInputModel	,
		SetComposingRangeReverseExtent
	)

Definition at line 210 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(4, 1));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [301/363]

flutter::TEST	(	TextInputModel	,
		SetComposingRangeStart
	)

Definition at line 170 of file text_input_model_unittests.cc.

                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(0, 0), 0));
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [302/363]

flutter::TEST	(	TextInputModel	,
		SetComposingRangeWithExtent
	)

Definition at line 200 of file text_input_model_unittests.cc.

                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [303/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionComposingEnd
	)

Definition at line 99 of file text_input_model_unittests.cc.

                                               {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->SetSelection(TextRange(4)));
  EXPECT_EQ(model->selection(), TextRange(4));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [304/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionComposingMiddle
	)

Definition at line 79 of file text_input_model_unittests.cc.

                                                  {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [305/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionComposingStart
	)

Definition at line 59 of file text_input_model_unittests.cc.

                                                 {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_TRUE(model->SetSelection(TextRange(1)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [306/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionEnd
	)

Definition at line 90 of file text_input_model_unittests.cc.

                                      {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(5)));
  EXPECT_EQ(model->selection(), TextRange(5));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [307/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionMiddle
	)

Definition at line 70 of file text_input_model_unittests.cc.

                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(2)));
  EXPECT_EQ(model->selection(), TextRange(2));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [308/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionOutsideComposingRange
	)

Definition at line 158 of file text_input_model_unittests.cc.

                                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_FALSE(model->SetSelection(TextRange(0)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_FALSE(model->SetSelection(TextRange(5)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
}

TEST() [309/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionOutsideString
	)

Definition at line 150 of file text_input_model_unittests.cc.

                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_FALSE(model->SetSelection(TextRange(4, 6)));
  EXPECT_FALSE(model->SetSelection(TextRange(5, 6)));
  EXPECT_FALSE(model->SetSelection(TextRange(6)));
}

TEST() [310/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionReverseExtent
	)

Definition at line 130 of file text_input_model_unittests.cc.

                                                {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
  EXPECT_EQ(model->selection(), TextRange(4, 1));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [311/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionReverseExtentComposing
	)

Definition at line 139 of file text_input_model_unittests.cc.

                                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_FALSE(model->SetSelection(TextRange(4, 1)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [312/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionStart
	)

Definition at line 50 of file text_input_model_unittests.cc.

                                        {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(0)));
  EXPECT_EQ(model->selection(), TextRange(0));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [313/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionWthExtent
	)

Definition at line 110 of file text_input_model_unittests.cc.

                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
  EXPECT_EQ(model->selection(), TextRange(1, 4));
  EXPECT_EQ(model->composing_range(), TextRange(0));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [314/363]

flutter::TEST	(	TextInputModel	,
		SetSelectionWthExtentComposing
	)

Definition at line 119 of file text_input_model_unittests.cc.

                                                     {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
  EXPECT_FALSE(model->SetSelection(TextRange(1, 4)));
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1, 4));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [315/363]

flutter::TEST	(	TextInputModel	,
		SetText
	)

Definition at line 15 of file text_input_model_unittests.cc.

                              {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
}

TEST() [316/363]

flutter::TEST	(	TextInputModel	,
		SetTextEmpty
	)

Definition at line 27 of file text_input_model_unittests.cc.

                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("");
  EXPECT_STREQ(model->GetText().c_str(), "");
}

TEST() [317/363]

flutter::TEST	(	TextInputModel	,
		SetTextReplaceText
	)

Definition at line 33 of file text_input_model_unittests.cc.

                                         {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
  model->SetText("");
  EXPECT_STREQ(model->GetText().c_str(), "");
}

TEST() [318/363]

flutter::TEST	(	TextInputModel	,
		SetTextResetsSelection
	)

Definition at line 41 of file text_input_model_unittests.cc.

                                             {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  EXPECT_TRUE(model->SetSelection(TextRange(3)));
  EXPECT_EQ(model->selection(), TextRange(3));
  model->SetText("FGHJI");
  EXPECT_EQ(model->selection(), TextRange(0));
}

TEST() [319/363]

flutter::TEST	(	TextInputModel	,
		SetTextWideCharacters
	)

Definition at line 21 of file text_input_model_unittests.cc.

                                            {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("😄🙃🤪🧐");
  EXPECT_STREQ(model->GetText().c_str(), "😄🙃🤪🧐");
}

TEST() [320/363]

flutter::TEST	(	TextInputModel	,
		UpdateComposingRemovesLastComposingCharacter
	)

Definition at line 395 of file text_input_model_unittests.cc.

                                                                   {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  model->SetComposingRange(TextRange(1, 2), 1);
  model->UpdateComposingText("");
  EXPECT_EQ(model->selection(), TextRange(1));
  EXPECT_EQ(model->composing_range(), TextRange(1));
  model->SetText("ACDE");
}

TEST() [321/363]

flutter::TEST	(	TextInputModel	,
		UpdateSelectionWhileComposing
	)

Definition at line 406 of file text_input_model_unittests.cc.

                                                    {
  auto model = std::make_unique<TextInputModel>();
  model->SetText("ABCDE");
  model->BeginComposing();
  model->SetComposingRange(TextRange(4, 5), 1);
  model->UpdateComposingText(u"ぴょんぴょん", TextRange(3, 6));
  EXPECT_STREQ(model->GetText().c_str(), "ABCDぴょんぴょん");
  EXPECT_EQ(model->selection(), TextRange(7, 10));
  EXPECT_EQ(model->composing_range(), TextRange(4, 10));
}

TEST() [322/363]

flutter::TEST	(	TextRange	,
		ContainsEndPosition
	)

Definition at line 125 of file text_range_unittests.cc.

                                     {
  TextRange range(2, 6);
  EXPECT_TRUE(range.Contains(6));
}

TEST() [323/363]

flutter::TEST	(	TextRange	,
		ContainsEndPositionReversed
	)

Definition at line 151 of file text_range_unittests.cc.

                                             {
  TextRange range(6, 2);
  EXPECT_TRUE(range.Contains(6));
}

TEST() [324/363]

flutter::TEST	(	TextRange	,
		ContainsMiddlePosition
	)

Definition at line 119 of file text_range_unittests.cc.

                                        {
  TextRange range(2, 6);
  EXPECT_TRUE(range.Contains(3));
  EXPECT_TRUE(range.Contains(4));
}

TEST() [325/363]

flutter::TEST	(	TextRange	,
		ContainsMiddlePositionReversed
	)

Definition at line 145 of file text_range_unittests.cc.

                                                {
  TextRange range(6, 2);
  EXPECT_TRUE(range.Contains(3));
  EXPECT_TRUE(range.Contains(4));
}

TEST() [326/363]

flutter::TEST	(	TextRange	,
		ContainsPostEndPosition
	)

Definition at line 130 of file text_range_unittests.cc.

                                         {
  TextRange range(2, 6);
  EXPECT_FALSE(range.Contains(7));
}

TEST() [327/363]

flutter::TEST	(	TextRange	,
		ContainsPostEndPositionReversed
	)

Definition at line 156 of file text_range_unittests.cc.

                                                 {
  TextRange range(6, 2);
  EXPECT_FALSE(range.Contains(7));
}

TEST() [328/363]

flutter::TEST	(	TextRange	,
		ContainsPreStartPosition
	)

Definition at line 109 of file text_range_unittests.cc.

                                          {
  TextRange range(2, 6);
  EXPECT_FALSE(range.Contains(1));
}

TEST() [329/363]

flutter::TEST	(	TextRange	,
		ContainsPreStartPositionReversed
	)

Definition at line 135 of file text_range_unittests.cc.

                                                  {
  TextRange range(6, 2);
  EXPECT_FALSE(range.Contains(1));
}

TEST() [330/363]

flutter::TEST	(	TextRange	,
		ContainsRangeEndPosition
	)

Definition at line 182 of file text_range_unittests.cc.

                                          {
  TextRange range(2, 6);
  EXPECT_TRUE(range.Contains(TextRange(6)));
}

TEST() [331/363]

flutter::TEST	(	TextRange	,
		ContainsRangeEndPositionReversed
	)

Definition at line 223 of file text_range_unittests.cc.

                                                  {
  TextRange range(6, 2);
  EXPECT_TRUE(range.Contains(TextRange(5)));
}

TEST() [332/363]

flutter::TEST	(	TextRange	,
		ContainsRangeMiddlePosition
	)

Definition at line 176 of file text_range_unittests.cc.

                                             {
  TextRange range(2, 6);
  EXPECT_TRUE(range.Contains(TextRange(3, 4)));
  EXPECT_TRUE(range.Contains(TextRange(4, 5)));
}

TEST() [333/363]

flutter::TEST	(	TextRange	,
		ContainsRangeMiddlePositionReversed
	)

Definition at line 212 of file text_range_unittests.cc.

                                                     {
  TextRange range(6, 2);
  EXPECT_TRUE(range.Contains(TextRange(3, 4)));
  EXPECT_TRUE(range.Contains(TextRange(4, 5)));
}

TEST() [334/363]

flutter::TEST	(	TextRange	,
		ContainsRangePostEndPosition
	)

Definition at line 192 of file text_range_unittests.cc.

                                              {
  TextRange range(2, 6);
  EXPECT_FALSE(range.Contains(TextRange(6, 7)));
}

TEST() [335/363]

flutter::TEST	(	TextRange	,
		ContainsRangePostEndPositionReversed
	)

Definition at line 228 of file text_range_unittests.cc.

                                                      {
  TextRange range(6, 2);
  EXPECT_FALSE(range.Contains(TextRange(6, 7)));
}

TEST() [336/363]

flutter::TEST	(	TextRange	,
		ContainsRangePreStartPosition
	)

Definition at line 161 of file text_range_unittests.cc.

                                               {
  TextRange range(2, 6);
  EXPECT_FALSE(range.Contains(TextRange(0, 1)));
}

TEST() [337/363]

flutter::TEST	(	TextRange	,
		ContainsRangePreStartPositionReversed
	)

Definition at line 197 of file text_range_unittests.cc.

                                                       {
  TextRange range(6, 2);
  EXPECT_FALSE(range.Contains(TextRange(0, 1)));
}

TEST() [338/363]

flutter::TEST	(	TextRange	,
		ContainsRangeSpanningEndPosition
	)

Definition at line 187 of file text_range_unittests.cc.

                                                  {
  TextRange range(2, 6);
  EXPECT_FALSE(range.Contains(TextRange(5, 7)));
}

TEST() [339/363]

flutter::TEST	(	TextRange	,
		ContainsRangeSpanningEndPositionReversed
	)

Definition at line 218 of file text_range_unittests.cc.

                                                          {
  TextRange range(6, 2);
  EXPECT_FALSE(range.Contains(TextRange(5, 7)));
}

TEST() [340/363]

flutter::TEST	(	TextRange	,
		ContainsRangeSpanningStartPosition
	)

Definition at line 166 of file text_range_unittests.cc.

                                                    {
  TextRange range(2, 6);
  EXPECT_FALSE(range.Contains(TextRange(1, 3)));
}

TEST() [341/363]

flutter::TEST	(	TextRange	,
		ContainsRangeSpanningStartPositionReversed
	)

Definition at line 202 of file text_range_unittests.cc.

                                                            {
  TextRange range(6, 2);
  EXPECT_FALSE(range.Contains(TextRange(1, 3)));
}

TEST() [342/363]

flutter::TEST	(	TextRange	,
		ContainsRangeStartPosition
	)

Definition at line 171 of file text_range_unittests.cc.

                                            {
  TextRange range(2, 6);
  EXPECT_TRUE(range.Contains(TextRange(2)));
}

TEST() [343/363]

flutter::TEST	(	TextRange	,
		ContainsRangeStartPositionReversed
	)

Definition at line 207 of file text_range_unittests.cc.

                                                    {
  TextRange range(6, 2);
  EXPECT_TRUE(range.Contains(TextRange(2)));
}

TEST() [344/363]

flutter::TEST	(	TextRange	,
		ContainsStartPosition
	)

Definition at line 114 of file text_range_unittests.cc.

                                       {
  TextRange range(2, 6);
  EXPECT_TRUE(range.Contains(2));
}

TEST() [345/363]

flutter::TEST	(	TextRange	,
		ContainsStartPositionReversed
	)

Definition at line 140 of file text_range_unittests.cc.

                                               {
  TextRange range(6, 2);
  EXPECT_TRUE(range.Contains(2));
}

TEST() [346/363]

flutter::TEST	(	TextRange	,
		ReversedCollapsedRange
	)

Definition at line 238 of file text_range_unittests.cc.

                                        {
  TextRange range(2, 2);
  EXPECT_FALSE(range.reversed());
}

TEST() [347/363]

flutter::TEST	(	TextRange	,
		ReversedForwardRange
	)

Definition at line 233 of file text_range_unittests.cc.

                                      {
  TextRange range(2, 6);
  EXPECT_FALSE(range.reversed());
}

TEST() [348/363]

flutter::TEST	(	TextRange	,
		ReversedReversedRange
	)

Definition at line 243 of file text_range_unittests.cc.

                                       {
  TextRange range(6, 2);
  EXPECT_TRUE(range.reversed());
}

TEST() [349/363]

flutter::TEST	(	TextRange	,
		SetBase
	)

Definition at line 53 of file text_range_unittests.cc.

                         {
  TextRange range(3, 7);
  range.set_base(4);
  EXPECT_EQ(range.base(), size_t(4));
  EXPECT_EQ(range.extent(), size_t(7));
}

TEST() [350/363]

flutter::TEST	(	TextRange	,
		SetBaseReversed
	)

Definition at line 60 of file text_range_unittests.cc.

                                 {
  TextRange range(7, 3);
  range.set_base(5);
  EXPECT_EQ(range.base(), size_t(5));
  EXPECT_EQ(range.extent(), size_t(3));
}

TEST() [351/363]

flutter::TEST	(	TextRange	,
		SetEnd
	)

Definition at line 95 of file text_range_unittests.cc.

                        {
  TextRange range(3, 7);
  range.set_end(6);
  EXPECT_EQ(range.base(), size_t(3));
  EXPECT_EQ(range.extent(), size_t(6));
}

TEST() [352/363]

flutter::TEST	(	TextRange	,
		SetEndReversed
	)

Definition at line 102 of file text_range_unittests.cc.

                                {
  TextRange range(7, 3);
  range.set_end(5);
  EXPECT_EQ(range.base(), size_t(5));
  EXPECT_EQ(range.extent(), size_t(3));
}

TEST() [353/363]

flutter::TEST	(	TextRange	,
		SetExtent
	)

Definition at line 67 of file text_range_unittests.cc.

                           {
  TextRange range(3, 7);
  range.set_extent(6);
  EXPECT_EQ(range.base(), size_t(3));
  EXPECT_EQ(range.extent(), size_t(6));
}

TEST() [354/363]

flutter::TEST	(	TextRange	,
		SetExtentReversed
	)

Definition at line 74 of file text_range_unittests.cc.

                                   {
  TextRange range(7, 3);
  range.set_extent(4);
  EXPECT_EQ(range.base(), size_t(7));
  EXPECT_EQ(range.extent(), size_t(4));
}

TEST() [355/363]

flutter::TEST	(	TextRange	,
		SetStart
	)

Definition at line 81 of file text_range_unittests.cc.

                          {
  TextRange range(3, 7);
  range.set_start(5);
  EXPECT_EQ(range.base(), size_t(5));
  EXPECT_EQ(range.extent(), size_t(7));
}

TEST() [356/363]

flutter::TEST	(	TextRange	,
		SetStartReversed
	)

Definition at line 88 of file text_range_unittests.cc.

                                  {
  TextRange range(7, 3);
  range.set_start(5);
  EXPECT_EQ(range.base(), size_t(7));
  EXPECT_EQ(range.extent(), size_t(5));
}

TEST() [357/363]

flutter::TEST	(	TextRange	,
		TextRangeFromPositionNonZero
	)

Definition at line 22 of file text_range_unittests.cc.

                                              {
  TextRange range(3);
  EXPECT_EQ(range.base(), size_t(3));
  EXPECT_EQ(range.extent(), size_t(3));
  EXPECT_EQ(range.start(), size_t(3));
  EXPECT_EQ(range.end(), size_t(3));
  EXPECT_EQ(range.length(), size_t(0));
  EXPECT_EQ(range.position(), size_t(3));
  EXPECT_TRUE(range.collapsed());
}

TEST() [358/363]

flutter::TEST	(	TextRange	,
		TextRangeFromPositionZero
	)

Definition at line 11 of file text_range_unittests.cc.

                                           {
  TextRange range(0);
  EXPECT_EQ(range.base(), size_t(0));
  EXPECT_EQ(range.extent(), size_t(0));
  EXPECT_EQ(range.start(), size_t(0));
  EXPECT_EQ(range.end(), size_t(0));
  EXPECT_EQ(range.length(), size_t(0));
  EXPECT_EQ(range.position(), size_t(0));
  EXPECT_TRUE(range.collapsed());
}

TEST() [359/363]

flutter::TEST	(	TextRange	,
		TextRangeFromRange
	)

Definition at line 33 of file text_range_unittests.cc.

                                    {
  TextRange range(3, 7);
  EXPECT_EQ(range.base(), size_t(3));
  EXPECT_EQ(range.extent(), size_t(7));
  EXPECT_EQ(range.start(), size_t(3));
  EXPECT_EQ(range.end(), size_t(7));
  EXPECT_EQ(range.length(), size_t(4));
  EXPECT_FALSE(range.collapsed());
}

TEST() [360/363]

flutter::TEST	(	TextRange	,
		TextRangeFromReversedRange
	)

Definition at line 43 of file text_range_unittests.cc.

                                            {
  TextRange range(7, 3);
  EXPECT_EQ(range.base(), size_t(7));
  EXPECT_EQ(range.extent(), size_t(3));
  EXPECT_EQ(range.start(), size_t(3));
  EXPECT_EQ(range.end(), size_t(7));
  EXPECT_EQ(range.length(), size_t(4));
  EXPECT_FALSE(range.collapsed());
}

TEST() [361/363]

flutter::TEST	(	TextureRegistrarTest	,
		MarkFrameAvailableInvalidTexture
	)

Definition at line 143 of file texture_registrar_unittests.cc.

                                                             {
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  PluginRegistrar registrar(dummy_registrar_handle);
 
  TextureRegistrar* textures = registrar.texture_registrar();
 
  bool success = textures->MarkTextureFrameAvailable(42);
  EXPECT_FALSE(success);
}

TEST() [362/363]

flutter::TEST	(	TextureRegistrarTest	,
		RegisterUnregisterTexture
	)

Definition at line 87 of file texture_registrar_unittests.cc.

                                                      {
  testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
  auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
 
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  PluginRegistrar registrar(dummy_registrar_handle);
  TextureRegistrar* textures = registrar.texture_registrar();
  ASSERT_NE(textures, nullptr);
 
  EXPECT_EQ(test_api->last_texture_id(), -1);
  auto texture = test_api->GetFakeTexture(0);
  EXPECT_EQ(texture, nullptr);
 
  auto pixel_buffer_texture = std::make_unique<TextureVariant>(
      PixelBufferTexture([](size_t width, size_t height) { return nullptr; }));
  int64_t texture_id = textures->RegisterTexture(pixel_buffer_texture.get());
  EXPECT_EQ(test_api->last_texture_id(), texture_id);
  EXPECT_EQ(test_api->textures_size(), static_cast<size_t>(1));
 
  texture = test_api->GetFakeTexture(texture_id);
  EXPECT_EQ(texture->texture_id, texture_id);
  EXPECT_EQ(texture->user_data,
            std::get_if<PixelBufferTexture>(pixel_buffer_texture.get()));
 
  textures->MarkTextureFrameAvailable(texture_id);
  textures->MarkTextureFrameAvailable(texture_id);
  bool success = textures->MarkTextureFrameAvailable(texture_id);
  EXPECT_TRUE(success);
  EXPECT_EQ(texture->mark_count, 3);
 
  fml::AutoResetWaitableEvent unregister_latch;
  textures->UnregisterTexture(texture_id, [&]() { unregister_latch.Signal(); });
  unregister_latch.Wait();
 
  texture = test_api->GetFakeTexture(texture_id);
  EXPECT_EQ(texture, nullptr);
  EXPECT_EQ(test_api->textures_size(), static_cast<size_t>(0));
}

TEST() [363/363]

flutter::TEST	(	TextureRegistrarTest	,
		UnregisterInvalidTexture
	)

Definition at line 129 of file texture_registrar_unittests.cc.

                                                     {
  auto dummy_registrar_handle =
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
  PluginRegistrar registrar(dummy_registrar_handle);
 
  TextureRegistrar* textures = registrar.texture_registrar();
 
  fml::AutoResetWaitableEvent latch;
  textures->UnregisterTexture(42, [&]() { latch.Signal(); });
  latch.Wait();
}

TEST_F() [1/19]

flutter::TEST_F	(	DartProjectTest	,
		DartEntrypointArguments
	)

Definition at line 45 of file dart_project_unittests.cc.

                                                 {
  DartProject project(L"test");
 
  std::vector<std::string> test_arguments = {"arg1", "arg2", "arg3"};
  project.set_dart_entrypoint_arguments(test_arguments);
 
  auto returned_arguments = project.dart_entrypoint_arguments();
  EXPECT_EQ(returned_arguments.size(), 3U);
  EXPECT_EQ(returned_arguments[0], "arg1");
  EXPECT_EQ(returned_arguments[1], "arg2");
  EXPECT_EQ(returned_arguments[2], "arg3");
}

TEST_F() [2/19]

flutter::TEST_F	(	DartProjectTest	,
		ProjectWithCustomPaths
	)

Definition at line 38 of file dart_project_unittests.cc.

                                                {
  DartProject project(L"data\\assets", L"icu\\icudtl.dat", L"lib\\file.so");
  EXPECT_EQ(GetProjectIcuDataPath(project), L"icu\\icudtl.dat");
  EXPECT_EQ(GetProjectAssetsPath(project), L"data\\assets");
  EXPECT_EQ(GetProjectAotLibraryPath(project), L"lib\\file.so");
}

TEST_F() [3/19]

flutter::TEST_F	(	DartProjectTest	,
		StandardProjectFormat
	)

Definition at line 31 of file dart_project_unittests.cc.

                                               {
  DartProject project(L"test");
  EXPECT_EQ(GetProjectIcuDataPath(project), L"test\\icudtl.dat");
  EXPECT_EQ(GetProjectAssetsPath(project), L"test\\flutter_assets");
  EXPECT_EQ(GetProjectAotLibraryPath(project), L"test\\app.so");
}

TEST_F() [4/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorAcceptsMultipleRenders
	)

Definition at line 266 of file engine_animator_unittests.cc.

                                                           {
  MockAnimatorDelegate animator_delegate;
  std::unique_ptr<EngineContext> engine_context;
 
  std::shared_ptr<PlatformMessageHandler> platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  EXPECT_CALL(delegate_, GetPlatformMessageHandler)
      .WillOnce(ReturnRef(platform_message_handler));
  fml::AutoResetWaitableEvent draw_latch;
  EXPECT_CALL(animator_delegate, OnAnimatorDraw)
      .WillOnce(
          Invoke([&draw_latch](const std::shared_ptr<FramePipeline>& pipeline) {
            auto status =
                pipeline->Consume([&](std::unique_ptr<FrameItem> item) {
                  auto tasks = Sorted(item->layer_tree_tasks);
                  EXPECT_EQ(tasks.size(), 2u);
                  EXPECT_EQ(tasks[0]->view_id, 1);
                  EXPECT_EQ(tasks[1]->view_id, 2);
                });
            EXPECT_EQ(status, PipelineConsumeResult::Done);
            draw_latch.Signal();
          }));
  EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
      .WillOnce(Invoke([&engine_context](fml::TimePoint frame_target_time,
                                         uint64_t frame_number) {
        engine_context->EngineTaskSync([&](Engine& engine) {
          engine.BeginFrame(frame_target_time, frame_number);
        });
      }));
 
  native_latch.Reset();
  AddNativeCallback("NotifyNative", [](auto args) { native_latch.Signal(); });
 
  std::unique_ptr<Animator> animator;
  PostSync(task_runners_.GetUITaskRunner(),
           [&animator, &animator_delegate, &task_runners = task_runners_] {
             animator = std::make_unique<Animator>(
                 animator_delegate, task_runners,
                 static_cast<std::unique_ptr<VsyncWaiter>>(
                     std::make_unique<testing::ConstantFiringVsyncWaiter>(
                         task_runners)));
           });
 
  engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                         std::move(animator));
  auto configuration = RunConfiguration::InferFromSettings(settings_);
  configuration.SetEntrypoint("onDrawFrameRenderAllViews");
  engine_context->Run(std::move(configuration));
 
  engine_context->EngineTaskSync([](Engine& engine) {
    engine.AddView(1, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
    engine.AddView(2, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
  });
 
  native_latch.Wait();
 
  engine_context->EngineTaskSync(
      [](Engine& engine) { engine.ScheduleFrame(); });
  draw_latch.Wait();
}

TEST_F() [5/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorSubmitPartialViewsForWarmUp
	)

Definition at line 593 of file engine_animator_unittests.cc.

                                                                {
  MockAnimatorDelegate animator_delegate;
  std::unique_ptr<EngineContext> engine_context;
 
  std::shared_ptr<PlatformMessageHandler> platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  EXPECT_CALL(delegate_, GetPlatformMessageHandler)
      .WillOnce(ReturnRef(platform_message_handler));
 
  fml::AutoResetWaitableEvent continuation_ready_latch;
  fml::AutoResetWaitableEvent draw_latch;
  EXPECT_CALL(animator_delegate, OnAnimatorDraw)
      .WillOnce(
          Invoke([&draw_latch](const std::shared_ptr<FramePipeline>& pipeline) {
            auto status =
                pipeline->Consume([&](std::unique_ptr<FrameItem> item) {
                  auto tasks = Sorted(item->layer_tree_tasks);
                  EXPECT_EQ(tasks.size(), 2u);
                  EXPECT_EQ(tasks[0]->view_id, 1);
                  EXPECT_EQ(tasks[1]->view_id, 2);
                });
            EXPECT_EQ(status, PipelineConsumeResult::Done);
            draw_latch.Signal();
          }));
  EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
      .WillRepeatedly(
          Invoke([&engine_context, &continuation_ready_latch](
                     fml::TimePoint frame_target_time, uint64_t frame_number) {
            continuation_ready_latch.Signal();
            engine_context->EngineTaskSync([&](Engine& engine) {
              engine.BeginFrame(frame_target_time, frame_number);
            });
          }));
 
  std::unique_ptr<Animator> animator;
  PostSync(task_runners_.GetUITaskRunner(),
           [&animator, &animator_delegate, &task_runners = task_runners_] {
             animator = std::make_unique<Animator>(
                 animator_delegate, task_runners,
                 static_cast<std::unique_ptr<VsyncWaiter>>(
                     std::make_unique<testing::ConstantFiringVsyncWaiter>(
                         task_runners)));
           });
 
  engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                         std::move(animator));
 
  engine_context->EngineTaskSync([](Engine& engine) {
    // Schedule a frame to make the animator create a continuation.
    engine.ScheduleFrame(true);
    // Add multiple views.
    engine.AddView(0, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
    engine.AddView(1, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
    engine.AddView(2, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
  });
 
  continuation_ready_latch.Wait();
 
  auto configuration = RunConfiguration::InferFromSettings(settings_);
  configuration.SetEntrypoint("renderWarmUpView1and2");
  engine_context->Run(std::move(configuration));
 
  draw_latch.Wait();
}

TEST_F() [6/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorSubmitsImplicitViewBeforeDrawFrameEnds
	)

Definition at line 462 of file engine_animator_unittests.cc.

                                                                           {
  MockAnimatorDelegate animator_delegate;
  std::unique_ptr<EngineContext> engine_context;
 
  std::shared_ptr<PlatformMessageHandler> platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  EXPECT_CALL(delegate_, GetPlatformMessageHandler)
      .WillOnce(ReturnRef(platform_message_handler));
 
  bool rasterization_started = false;
  EXPECT_CALL(animator_delegate, OnAnimatorDraw)
      .WillOnce(Invoke([&rasterization_started](
                           const std::shared_ptr<FramePipeline>& pipeline) {
        rasterization_started = true;
        auto status = pipeline->Consume([&](std::unique_ptr<FrameItem> item) {
          EXPECT_EQ(item->layer_tree_tasks.size(), 1u);
          EXPECT_EQ(item->layer_tree_tasks[0]->view_id, kFlutterImplicitViewId);
        });
        EXPECT_EQ(status, PipelineConsumeResult::Done);
      }));
  EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
      .WillRepeatedly(Invoke([&engine_context](fml::TimePoint frame_target_time,
                                               uint64_t frame_number) {
        engine_context->EngineTaskSync([&](Engine& engine) {
          engine.BeginFrame(frame_target_time, frame_number);
        });
      }));
 
  std::unique_ptr<Animator> animator;
  PostSync(task_runners_.GetUITaskRunner(),
           [&animator, &animator_delegate, &task_runners = task_runners_] {
             animator = std::make_unique<Animator>(
                 animator_delegate, task_runners,
                 static_cast<std::unique_ptr<VsyncWaiter>>(
                     std::make_unique<testing::ConstantFiringVsyncWaiter>(
                         task_runners)));
           });
 
  native_latch.Reset();
  // The native_latch is signaled at the end of handleDrawFrame.
  AddNativeCallback("NotifyNative",
                    CREATE_NATIVE_ENTRY([&rasterization_started](auto args) {
                      EXPECT_EQ(rasterization_started, true);
                      native_latch.Signal();
                    }));
 
  engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                         std::move(animator));
 
  engine_context->EngineTaskSync([](Engine& engine) {
    engine.AddView(kFlutterImplicitViewId, ViewportMetrics{1.0, 10, 10, 1, 0},
                   [](bool added) { ASSERT_TRUE(added); });
  });
 
  auto configuration = RunConfiguration::InferFromSettings(settings_);
  configuration.SetEntrypoint("renderSingleViewAndCallAfterOnDrawFrame");
  engine_context->Run(std::move(configuration));
 
  native_latch.Wait();
}

TEST_F() [7/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorSubmitWarmUpImplicitView
	)

Definition at line 526 of file engine_animator_unittests.cc.

                                                             {
  MockAnimatorDelegate animator_delegate;
  std::unique_ptr<EngineContext> engine_context;
 
  std::shared_ptr<PlatformMessageHandler> platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  EXPECT_CALL(delegate_, GetPlatformMessageHandler)
      .WillOnce(ReturnRef(platform_message_handler));
 
  fml::AutoResetWaitableEvent continuation_ready_latch;
  fml::AutoResetWaitableEvent draw_latch;
  EXPECT_CALL(animator_delegate, OnAnimatorDraw)
      .WillOnce(Invoke([&draw_latch](
                           const std::shared_ptr<FramePipeline>& pipeline) {
        auto status = pipeline->Consume([&](std::unique_ptr<FrameItem> item) {
          EXPECT_EQ(item->layer_tree_tasks.size(), 1u);
          EXPECT_EQ(item->layer_tree_tasks[0]->view_id, kFlutterImplicitViewId);
        });
        EXPECT_EQ(status, PipelineConsumeResult::Done);
        draw_latch.Signal();
      }));
  EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
      .WillRepeatedly(
          Invoke([&engine_context, &continuation_ready_latch](
                     fml::TimePoint frame_target_time, uint64_t frame_number) {
            continuation_ready_latch.Signal();
            engine_context->EngineTaskSync([&](Engine& engine) {
              engine.BeginFrame(frame_target_time, frame_number);
            });
          }));
 
  std::unique_ptr<Animator> animator;
  PostSync(task_runners_.GetUITaskRunner(),
           [&animator, &animator_delegate, &task_runners = task_runners_] {
             animator = std::make_unique<Animator>(
                 animator_delegate, task_runners,
                 static_cast<std::unique_ptr<VsyncWaiter>>(
                     std::make_unique<testing::ConstantFiringVsyncWaiter>(
                         task_runners)));
           });
 
  engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                         std::move(animator));
 
  engine_context->EngineTaskSync([](Engine& engine) {
    // Schedule a frame to trigger Animator::BeginFrame to create a
    // continuation. The continuation needs to be available before `Engine::Run`
    // since the Dart program immediately schedules a warm up frame.
    engine.ScheduleFrame(true);
    // Add the implicit view so that the engine recognizes it and that its
    // metrics is not empty.
    engine.AddView(kFlutterImplicitViewId, ViewportMetrics{1.0, 10, 10, 1, 0},
                   [](bool added) { ASSERT_TRUE(added); });
  });
  continuation_ready_latch.Wait();
 
  auto configuration = RunConfiguration::InferFromSettings(settings_);
  configuration.SetEntrypoint("renderWarmUpImplicitView");
  engine_context->Run(std::move(configuration));
 
  draw_latch.Wait();
}

TEST_F() [8/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		IgnoresDuplicateRenders
	)

Definition at line 386 of file engine_animator_unittests.cc.

                                                    {
  MockAnimatorDelegate animator_delegate;
  std::unique_ptr<EngineContext> engine_context;
 
  std::vector<std::shared_ptr<Layer>> benchmark_layers;
  auto capture_root_layer = [&benchmark_layers](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
    SceneBuilder* scene_builder = reinterpret_cast<SceneBuilder*>(peer);
    ASSERT_TRUE(scene_builder);
    std::shared_ptr<ContainerLayer> root_layer =
        scene_builder->layer_stack()[0];
    ASSERT_TRUE(root_layer);
    benchmark_layers = root_layer->layers();
  };
 
  std::shared_ptr<PlatformMessageHandler> platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  EXPECT_CALL(delegate_, GetPlatformMessageHandler)
      .WillOnce(ReturnRef(platform_message_handler));
  fml::AutoResetWaitableEvent draw_latch;
  EXPECT_CALL(animator_delegate, OnAnimatorDraw)
      .WillOnce(Invoke([&draw_latch, &benchmark_layers](
                           const std::shared_ptr<FramePipeline>& pipeline) {
        auto status = pipeline->Consume([&](std::unique_ptr<FrameItem> item) {
          EXPECT_EQ(item->layer_tree_tasks.size(), 1u);
          EXPECT_EQ(item->layer_tree_tasks[0]->view_id, kFlutterImplicitViewId);
          ContainerLayer* root_layer = reinterpret_cast<ContainerLayer*>(
              item->layer_tree_tasks[0]->layer_tree->root_layer());
          std::vector<std::shared_ptr<Layer>> result_layers =
              root_layer->layers();
          EXPECT_EQ(result_layers.size(), benchmark_layers.size());
          EXPECT_EQ(result_layers[0], benchmark_layers[0]);
        });
        EXPECT_EQ(status, PipelineConsumeResult::Done);
        draw_latch.Signal();
      }));
  EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
      .WillOnce(Invoke([&engine_context](fml::TimePoint frame_target_time,
                                         uint64_t frame_number) {
        engine_context->EngineTaskSync([&](Engine& engine) {
          engine.BeginFrame(frame_target_time, frame_number);
        });
      }));
 
  AddNativeCallback("CaptureRootLayer",
                    CREATE_NATIVE_ENTRY(capture_root_layer));
 
  std::unique_ptr<Animator> animator;
  PostSync(task_runners_.GetUITaskRunner(),
           [&animator, &animator_delegate, &task_runners = task_runners_] {
             animator = std::make_unique<Animator>(
                 animator_delegate, task_runners,
                 static_cast<std::unique_ptr<VsyncWaiter>>(
                     std::make_unique<testing::ConstantFiringVsyncWaiter>(
                         task_runners)));
           });
 
  engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                         std::move(animator));
 
  engine_context->EngineTaskSync([](Engine& engine) {
    engine.AddView(kFlutterImplicitViewId, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
  });
 
  auto configuration = RunConfiguration::InferFromSettings(settings_);
  configuration.SetEntrypoint("renderTwiceForOneView");
  engine_context->Run(std::move(configuration));
 
  draw_latch.Wait();
}

TEST_F() [9/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		IgnoresOutOfFrameRenders
	)

Definition at line 329 of file engine_animator_unittests.cc.

                                                     {
  MockAnimatorDelegate animator_delegate;
  std::unique_ptr<EngineContext> engine_context;
 
  std::shared_ptr<PlatformMessageHandler> platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  EXPECT_CALL(delegate_, GetPlatformMessageHandler)
      .WillOnce(ReturnRef(platform_message_handler));
  fml::AutoResetWaitableEvent draw_latch;
  EXPECT_CALL(animator_delegate, OnAnimatorDraw)
      .WillOnce(
          Invoke([&draw_latch](const std::shared_ptr<FramePipeline>& pipeline) {
            auto status =
                pipeline->Consume([&](std::unique_ptr<FrameItem> item) {
                  // View 1 is rendered before the frame, and is ignored.
                  // View 2 is rendered within the frame, and is accepted.
                  EXPECT_EQ(item->layer_tree_tasks.size(), 1u);
                  EXPECT_EQ(item->layer_tree_tasks[0]->view_id, 2);
                });
            EXPECT_EQ(status, PipelineConsumeResult::Done);
            draw_latch.Signal();
          }));
  EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
      .WillOnce(Invoke([&engine_context](fml::TimePoint frame_target_time,
                                         uint64_t frame_number) {
        engine_context->EngineTaskSync([&](Engine& engine) {
          engine.BeginFrame(frame_target_time, frame_number);
        });
      }));
 
  std::unique_ptr<Animator> animator;
  PostSync(task_runners_.GetUITaskRunner(),
           [&animator, &animator_delegate, &task_runners = task_runners_] {
             animator = std::make_unique<Animator>(
                 animator_delegate, task_runners,
                 static_cast<std::unique_ptr<VsyncWaiter>>(
                     std::make_unique<testing::ConstantFiringVsyncWaiter>(
                         task_runners)));
           });
 
  engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                         std::move(animator));
 
  engine_context->EngineTaskSync([](Engine& engine) {
    engine.AddView(1, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
    engine.AddView(2, ViewportMetrics{1, 10, 10, 22, 0},
                   [](bool added) { ASSERT_TRUE(added); });
  });
 
  auto configuration = RunConfiguration::InferFromSettings(settings_);
  configuration.SetEntrypoint("renderViewsInFrameAndOutOfFrame");
  engine_context->Run(std::move(configuration));
 
  draw_latch.Wait();
}

TEST_F() [10/19]

flutter::TEST_F	(	EngineTest	,
		Create
	)

Definition at line 238 of file engine_unittests.cc.

                           {
  PostUITaskSync([this] {
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(runtime_controller_),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
    EXPECT_TRUE(engine);
  });
}

TEST_F() [11/19]

flutter::TEST_F	(	EngineTest	,
		DispatchPlatformMessageInitialRoute
	)

Definition at line 282 of file engine_unittests.cc.

                                                        {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    EXPECT_CALL(*mock_runtime_controller, IsRootIsolateRunning())
        .WillRepeatedly(::testing::Return(false));
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    fml::RefPtr<PlatformMessageResponse> response =
        fml::MakeRefCounted<MockResponse>();
    std::map<std::string, std::string> values{
        {"method", "setInitialRoute"},
        {"args", "test_initial_route"},
    };
    std::unique_ptr<PlatformMessage> message =
        MakePlatformMessage("flutter/navigation", values, response);
    engine->DispatchPlatformMessage(std::move(message));
    EXPECT_EQ(engine->InitialRoute(), "test_initial_route");
  });
}

TEST_F() [12/19]

flutter::TEST_F	(	EngineTest	,
		DispatchPlatformMessageInitialRouteIgnored
	)

Definition at line 314 of file engine_unittests.cc.

                                                               {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    EXPECT_CALL(*mock_runtime_controller, IsRootIsolateRunning())
        .WillRepeatedly(::testing::Return(true));
    EXPECT_CALL(*mock_runtime_controller, DispatchPlatformMessage(::testing::_))
        .WillRepeatedly(::testing::Return(true));
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    fml::RefPtr<PlatformMessageResponse> response =
        fml::MakeRefCounted<MockResponse>();
    std::map<std::string, std::string> values{
        {"method", "setInitialRoute"},
        {"args", "test_initial_route"},
    };
    std::unique_ptr<PlatformMessage> message =
        MakePlatformMessage("flutter/navigation", values, response);
    engine->DispatchPlatformMessage(std::move(message));
    EXPECT_EQ(engine->InitialRoute(), "");
  });
}

TEST_F() [13/19]

flutter::TEST_F	(	EngineTest	,
		DispatchPlatformMessageUnknown
	)

Definition at line 255 of file engine_unittests.cc.

                                                   {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    EXPECT_CALL(*mock_runtime_controller, IsRootIsolateRunning())
        .WillRepeatedly(::testing::Return(false));
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    fml::RefPtr<PlatformMessageResponse> response =
        fml::MakeRefCounted<MockResponse>();
    std::unique_ptr<PlatformMessage> message =
        std::make_unique<PlatformMessage>("foo", response);
    engine->DispatchPlatformMessage(std::move(message));
  });
}

TEST_F() [14/19]

flutter::TEST_F	(	EngineTest	,
		PassesLoadDartDeferredLibraryErrorToRuntime
	)

Definition at line 441 of file engine_unittests.cc.

                                                                {
  PostUITaskSync([this] {
    intptr_t error_id = 123;
    const std::string error_message = "error message";
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    EXPECT_CALL(*mock_runtime_controller, IsRootIsolateRunning())
        .WillRepeatedly(::testing::Return(true));
    EXPECT_CALL(*mock_runtime_controller,
                LoadDartDeferredLibraryError(error_id, error_message, true))
        .Times(1);
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    engine->LoadDartDeferredLibraryError(error_id, error_message, true);
  });
}

TEST_F() [15/19]

flutter::TEST_F	(	EngineTest	,
		SpawnedEngineInheritsAssetManager
	)

Definition at line 469 of file engine_unittests.cc.

                                                      {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    auto vm_ref = DartVMRef::Create(settings_);
    EXPECT_CALL(*mock_runtime_controller, GetDartVM())
        .WillRepeatedly(::testing::Return(vm_ref.get()));
 
    // auto mock_font_collection = std::make_shared<MockFontCollection>();
    // EXPECT_CALL(*mock_font_collection, RegisterFonts(::testing::_))
    //     .WillOnce(::testing::Return());
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    EXPECT_EQ(engine->GetAssetManager(), nullptr);
 
    auto asset_manager = std::make_shared<AssetManager>();
    asset_manager->PushBack(std::make_unique<FontManifestAssetResolver>());
    engine->UpdateAssetManager(asset_manager);
    EXPECT_EQ(engine->GetAssetManager(), asset_manager);
 
    auto spawn =
        engine->Spawn(delegate_, dispatcher_maker_, settings_, nullptr,
                      std::string(), io_manager_, snapshot_delegate_, nullptr);
    EXPECT_TRUE(spawn != nullptr);
    EXPECT_EQ(engine->GetAssetManager(), spawn->GetAssetManager());
  });
}

TEST_F() [16/19]

flutter::TEST_F	(	EngineTest	,
		SpawnSharesFontLibrary
	)

Definition at line 348 of file engine_unittests.cc.

                                           {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    auto vm_ref = DartVMRef::Create(settings_);
    EXPECT_CALL(*mock_runtime_controller, GetDartVM())
        .WillRepeatedly(::testing::Return(vm_ref.get()));
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    auto spawn =
        engine->Spawn(delegate_, dispatcher_maker_, settings_, nullptr,
                      std::string(), io_manager_, snapshot_delegate_, nullptr);
    EXPECT_TRUE(spawn != nullptr);
    EXPECT_EQ(&engine->GetFontCollection(), &spawn->GetFontCollection());
  });
}

TEST_F() [17/19]

flutter::TEST_F	(	EngineTest	,
		SpawnWithCustomInitialRoute
	)

Definition at line 376 of file engine_unittests.cc.

                                                {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    auto vm_ref = DartVMRef::Create(settings_);
    EXPECT_CALL(*mock_runtime_controller, GetDartVM())
        .WillRepeatedly(::testing::Return(vm_ref.get()));
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    auto spawn =
        engine->Spawn(delegate_, dispatcher_maker_, settings_, nullptr, "/foo",
                      io_manager_, snapshot_delegate_, nullptr);
    EXPECT_TRUE(spawn != nullptr);
    ASSERT_EQ("/foo", spawn->InitialRoute());
  });
}

TEST_F() [18/19]

flutter::TEST_F	(	EngineTest	,
		SpawnWithCustomSettings
	)

Definition at line 404 of file engine_unittests.cc.

                                            {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    auto vm_ref = DartVMRef::Create(settings_);
    EXPECT_CALL(*mock_runtime_controller, GetDartVM())
        .WillRepeatedly(::testing::Return(vm_ref.get()));
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/std::make_shared<FontCollection>(),
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    Settings custom_settings = settings_;
    custom_settings.persistent_isolate_data =
        std::make_shared<fml::DataMapping>("foo");
    auto spawn =
        engine->Spawn(delegate_, dispatcher_maker_, custom_settings, nullptr,
                      std::string(), io_manager_, snapshot_delegate_, nullptr);
    EXPECT_TRUE(spawn != nullptr);
    auto new_persistent_isolate_data =
        const_cast<RuntimeController*>(spawn->GetRuntimeController())
            ->GetPersistentIsolateData();
    EXPECT_EQ(custom_settings.persistent_isolate_data->GetMapping(),
              new_persistent_isolate_data->GetMapping());
    EXPECT_EQ(custom_settings.persistent_isolate_data->GetSize(),
              new_persistent_isolate_data->GetSize());
  });
}

TEST_F() [19/19]

flutter::TEST_F	(	EngineTest	,
		UpdateAssetManagerWithEqualManagers
	)

Definition at line 508 of file engine_unittests.cc.

                                                        {
  PostUITaskSync([this] {
    MockRuntimeDelegate client;
    auto mock_runtime_controller =
        std::make_unique<MockRuntimeController>(client, task_runners_);
    auto vm_ref = DartVMRef::Create(settings_);
    EXPECT_CALL(*mock_runtime_controller, GetDartVM())
        .WillRepeatedly(::testing::Return(vm_ref.get()));
 
    auto mock_font_collection = std::make_shared<MockFontCollection>();
    EXPECT_CALL(*mock_font_collection, RegisterFonts(::testing::_))
        .WillOnce(::testing::Return());
    auto engine = std::make_unique<Engine>(
        /*delegate=*/delegate_,
        /*dispatcher_maker=*/dispatcher_maker_,
        /*image_decoder_task_runner=*/image_decoder_task_runner_,
        /*task_runners=*/task_runners_,
        /*settings=*/settings_,
        /*animator=*/std::move(animator_),
        /*io_manager=*/io_manager_,
        /*font_collection=*/mock_font_collection,
        /*runtime_controller=*/std::move(mock_runtime_controller),
        /*gpu_disabled_switch=*/std::make_shared<fml::SyncSwitch>());
 
    EXPECT_EQ(engine->GetAssetManager(), nullptr);
 
    auto asset_manager = std::make_shared<AssetManager>();
    asset_manager->PushBack(std::make_unique<FontManifestAssetResolver>());
 
    auto asset_manager_2 = std::make_shared<AssetManager>();
    asset_manager_2->PushBack(std::make_unique<FontManifestAssetResolver>());
 
    EXPECT_NE(asset_manager, asset_manager_2);
    EXPECT_TRUE(*asset_manager == *asset_manager_2);
 
    engine->UpdateAssetManager(asset_manager);
    EXPECT_EQ(engine->GetAssetManager(), asset_manager);
 
    engine->UpdateAssetManager(asset_manager_2);
    // Didn't change because they're equivalent.
    EXPECT_EQ(engine->GetAssetManager(), asset_manager);
  });
}

ThreadExitCallback()

void flutter::ThreadExitCallback

(

)

Definition at line 161 of file dart_vm.cc.

{}

ToDlISize()

const DlISize & flutter::ToDlISize ( const SkISize &  size )

inline

Definition at line 46 of file dl_geometry_types.h.

                                                     {
  return *reinterpret_cast<const DlISize*>(&size);
}

ToDlMatrix() [1/2]

constexpr DlMatrix flutter::ToDlMatrix ( const SkM44 &  matrix )

inlineconstexpr

Definition at line 61 of file dl_geometry_types.h.

                                                          {
  DlMatrix dl_matrix;
  matrix.getColMajor(dl_matrix.m);
  return dl_matrix;
}

ToDlMatrix() [2/2]

constexpr DlMatrix flutter::ToDlMatrix ( const SkMatrix &  matrix )

inlineconstexpr

Definition at line 50 of file dl_geometry_types.h.

                                                             {
  // clang-format off
  return DlMatrix::MakeColumn(
      matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY],  0.0f, matrix[SkMatrix::kMPersp0],
      matrix[SkMatrix::kMSkewX],  matrix[SkMatrix::kMScaleY], 0.0f, matrix[SkMatrix::kMPersp1],
      0.0f,                       0.0f,                       1.0f, 0.0f,
      matrix[SkMatrix::kMTransX], matrix[SkMatrix::kMTransY], 0.0f, matrix[SkMatrix::kMPersp2]
  );
  // clang-format on
}

ToDlPoint()

const DlPoint & flutter::ToDlPoint ( const SkPoint &  point )

inline

Definition at line 38 of file dl_geometry_types.h.

                                                      {
  return *reinterpret_cast<const DlPoint*>(&point);
}

ToDlRect()

const DlRect & flutter::ToDlRect ( const SkRect &  rect )

inline

Definition at line 42 of file dl_geometry_types.h.

                                                  {
  return *reinterpret_cast<const DlRect*>(&rect);
}

toLower()

static uint64_t flutter::toLower ( uint64_t  n )

static

Definition at line 80 of file keyboard_key_embedder_handler.cc.

                                    {
  constexpr uint64_t lower_a = 0x61;
  constexpr uint64_t upper_a = 0x41;
  constexpr uint64_t upper_z = 0x5a;
 
  constexpr uint64_t lower_a_grave = 0xe0;
  constexpr uint64_t upper_a_grave = 0xc0;
  constexpr uint64_t upper_thorn = 0xde;
  constexpr uint64_t division = 0xf7;
 
  // ASCII range.
  if (n >= upper_a && n <= upper_z) {
    return n - upper_a + lower_a;
  }
 
  // EASCII range.
  if (n >= upper_a_grave && n <= upper_thorn && n != division) {
    return n - upper_a_grave + lower_a_grave;
  }
 
  return n;
}

ToMatrix()

static impeller::Matrix flutter::ToMatrix ( const tonic::Float64List &  matrix4 )

static

Definition at line 102 of file scene_node.cc.

                                                                {
  return impeller::Matrix(static_cast<impeller::Scalar>(matrix4[0]),
                          static_cast<impeller::Scalar>(matrix4[1]),
                          static_cast<impeller::Scalar>(matrix4[2]),
                          static_cast<impeller::Scalar>(matrix4[3]),
                          static_cast<impeller::Scalar>(matrix4[4]),
                          static_cast<impeller::Scalar>(matrix4[5]),
                          static_cast<impeller::Scalar>(matrix4[6]),
                          static_cast<impeller::Scalar>(matrix4[7]),
                          static_cast<impeller::Scalar>(matrix4[8]),
                          static_cast<impeller::Scalar>(matrix4[9]),
                          static_cast<impeller::Scalar>(matrix4[10]),
                          static_cast<impeller::Scalar>(matrix4[11]),
                          static_cast<impeller::Scalar>(matrix4[12]),
                          static_cast<impeller::Scalar>(matrix4[13]),
                          static_cast<impeller::Scalar>(matrix4[14]),
                          static_cast<impeller::Scalar>(matrix4[15]));
}

ToMatrix4()

tonic::Float64List flutter::ToMatrix4

(

const SkMatrix &

sk_matrix

)

Definition at line 46 of file matrix.cc.

                                                      {
  tonic::Float64List matrix4(Dart_NewTypedData(Dart_TypedData_kFloat64, 16));
  for (int i = 0; i < 9; ++i) {
    matrix4[kSkMatrixIndexToMatrix4Index[i]] = sk_matrix[i];
  }
  matrix4[10] = 1.0;  // Identity along the z axis.
  return matrix4;
}

ToNonShaderSk()

SkPaint flutter::ToNonShaderSk

(

const DlPaint &

paint

)

Definition at line 62 of file dl_sk_conversions.cc.

                                            {
  DlPaint non_shader_paint = paint;
  non_shader_paint.setColorSource(nullptr);
  return ToSk(non_shader_paint);
}

ToSk() [1/29]

SkBlurStyle flutter::ToSk ( const DlBlurStyle  blur_style )

inline

Definition at line 43 of file dl_sk_conversions.h.

                                                      {
  return static_cast<SkBlurStyle>(blur_style);
}

ToSk() [2/29]

sk_sp< SkColorFilter > flutter::ToSk ( const DlColorFilter &  filter )

inline

Definition at line 104 of file dl_sk_conversions.h.

                                                              {
  return ToSk(&filter);
}

ToSk() [3/29]

sk_sp< SkColorFilter > flutter::ToSk

(

const DlColorFilter *

filter

)

Definition at line 235 of file dl_sk_conversions.cc.

                                                       {
  if (!filter) {
    return nullptr;
  }
  switch (filter->type()) {
    case DlColorFilterType::kBlend: {
      const DlBlendColorFilter* blend_filter = filter->asBlend();
      FML_DCHECK(blend_filter != nullptr);
      return SkColorFilters::Blend(ToSk(blend_filter->color()),
                                   ToSk(blend_filter->mode()));
    }
    case DlColorFilterType::kMatrix: {
      const DlMatrixColorFilter* matrix_filter = filter->asMatrix();
      FML_DCHECK(matrix_filter != nullptr);
      float matrix[20];
      matrix_filter->get_matrix(matrix);
      return SkColorFilters::Matrix(matrix);
    }
    case DlColorFilterType::kSrgbToLinearGamma: {
      return SkColorFilters::SRGBToLinearGamma();
    }
    case DlColorFilterType::kLinearToSrgbGamma: {
      return SkColorFilters::LinearToSRGBGamma();
    }
  }
}

ToSk() [4/29]

sk_sp< SkShader > flutter::ToSk ( const DlColorSource &  source )

inline

Definition at line 86 of file dl_sk_conversions.h.

                                                         {
  return ToSk(&source);
}

ToSk() [5/29]

sk_sp< SkShader > flutter::ToSk

(

const DlColorSource *

source

)

Definition at line 68 of file dl_sk_conversions.cc.

                                                  {
  if (!source) {
    return nullptr;
  }
  static auto ToSkColors = [](const DlGradientColorSourceBase* gradient) {
    return reinterpret_cast<const SkColor*>(gradient->colors());
  };
  switch (source->type()) {
    case DlColorSourceType::kColor: {
      const DlColorColorSource* color_source = source->asColor();
      FML_DCHECK(color_source != nullptr);
      return SkShaders::Color(ToSk(color_source->color()));
    }
    case DlColorSourceType::kImage: {
      const DlImageColorSource* image_source = source->asImage();
      FML_DCHECK(image_source != nullptr);
      auto image = image_source->image();
      if (!image || !image->skia_image()) {
        return nullptr;
      }
      return image->skia_image()->makeShader(
          ToSk(image_source->horizontal_tile_mode()),
          ToSk(image_source->vertical_tile_mode()),
          ToSk(image_source->sampling()), image_source->matrix_ptr());
    }
    case DlColorSourceType::kLinearGradient: {
      const DlLinearGradientColorSource* linear_source =
          source->asLinearGradient();
      FML_DCHECK(linear_source != nullptr);
      SkPoint pts[] = {linear_source->start_point(),
                       linear_source->end_point()};
      return SkGradientShader::MakeLinear(
          pts, ToSkColors(linear_source), linear_source->stops(),
          linear_source->stop_count(), ToSk(linear_source->tile_mode()), 0,
          linear_source->matrix_ptr());
    }
    case DlColorSourceType::kRadialGradient: {
      const DlRadialGradientColorSource* radial_source =
          source->asRadialGradient();
      FML_DCHECK(radial_source != nullptr);
      return SkGradientShader::MakeRadial(
          radial_source->center(), radial_source->radius(),
          ToSkColors(radial_source), radial_source->stops(),
          radial_source->stop_count(), ToSk(radial_source->tile_mode()), 0,
          radial_source->matrix_ptr());
    }
    case DlColorSourceType::kConicalGradient: {
      const DlConicalGradientColorSource* conical_source =
          source->asConicalGradient();
      FML_DCHECK(conical_source != nullptr);
      return SkGradientShader::MakeTwoPointConical(
          conical_source->start_center(), conical_source->start_radius(),
          conical_source->end_center(), conical_source->end_radius(),
          ToSkColors(conical_source), conical_source->stops(),
          conical_source->stop_count(), ToSk(conical_source->tile_mode()), 0,
          conical_source->matrix_ptr());
    }
    case DlColorSourceType::kSweepGradient: {
      const DlSweepGradientColorSource* sweep_source =
          source->asSweepGradient();
      FML_DCHECK(sweep_source != nullptr);
      return SkGradientShader::MakeSweep(
          sweep_source->center().x(), sweep_source->center().y(),
          ToSkColors(sweep_source), sweep_source->stops(),
          sweep_source->stop_count(), ToSk(sweep_source->tile_mode()),
          sweep_source->start(), sweep_source->end(), 0,
          sweep_source->matrix_ptr());
    }
    case DlColorSourceType::kRuntimeEffect: {
      const DlRuntimeEffectColorSource* runtime_source =
          source->asRuntimeEffect();
      FML_DCHECK(runtime_source != nullptr);
      auto runtime_effect = runtime_source->runtime_effect();
      if (!runtime_effect || !runtime_effect->skia_runtime_effect()) {
        return nullptr;
      }
 
      auto samplers = runtime_source->samplers();
      std::vector<sk_sp<SkShader>> sk_samplers(samplers.size());
      for (size_t i = 0; i < samplers.size(); i++) {
        auto sampler = samplers[i];
        if (sampler == nullptr) {
          return nullptr;
        }
        sk_samplers[i] = ToSk(sampler);
      }
 
      auto uniform_data = runtime_source->uniform_data();
      auto ref = new std::shared_ptr<std::vector<uint8_t>>(uniform_data);
      auto sk_uniform_data = SkData::MakeWithProc(
          uniform_data->data(), uniform_data->size(),
          [](const void* ptr, void* context) {
            delete reinterpret_cast<std::shared_ptr<std::vector<uint8_t>>*>(
                context);
          },
          ref);
 
      return runtime_effect->skia_runtime_effect()->makeShader(
          sk_uniform_data, sk_samplers.data(), sk_samplers.size());
    }
#ifdef IMPELLER_ENABLE_3D
    case DlColorSourceType::kScene: {
      return nullptr;
    }
#endif  // IMPELLER_ENABLE_3D
  }
}

ToSk() [6/29]

SkFilterMode flutter::ToSk ( const DlFilterMode  filter_mode )

inline

Definition at line 47 of file dl_sk_conversions.h.

                                                         {
  return static_cast<SkFilterMode>(filter_mode);
}

ToSk() [7/29]

sk_sp< SkImageFilter > flutter::ToSk ( const DlImageFilter &  filter )

inline

Definition at line 95 of file dl_sk_conversions.h.

                                                              {
  return ToSk(&filter);
}

ToSk() [8/29]

sk_sp< SkImageFilter > flutter::ToSk

(

const DlImageFilter *

filter

)

Definition at line 176 of file dl_sk_conversions.cc.

                                                       {
  if (!filter) {
    return nullptr;
  }
  switch (filter->type()) {
    case DlImageFilterType::kBlur: {
      const DlBlurImageFilter* blur_filter = filter->asBlur();
      FML_DCHECK(blur_filter != nullptr);
      return SkImageFilters::Blur(blur_filter->sigma_x(),
                                  blur_filter->sigma_y(),
                                  ToSk(blur_filter->tile_mode()), nullptr);
    }
    case DlImageFilterType::kDilate: {
      const DlDilateImageFilter* dilate_filter = filter->asDilate();
      FML_DCHECK(dilate_filter != nullptr);
      return SkImageFilters::Dilate(dilate_filter->radius_x(),
                                    dilate_filter->radius_y(), nullptr);
    }
    case DlImageFilterType::kErode: {
      const DlErodeImageFilter* erode_filter = filter->asErode();
      FML_DCHECK(erode_filter != nullptr);
      return SkImageFilters::Erode(erode_filter->radius_x(),
                                   erode_filter->radius_y(), nullptr);
    }
    case DlImageFilterType::kMatrix: {
      const DlMatrixImageFilter* matrix_filter = filter->asMatrix();
      FML_DCHECK(matrix_filter != nullptr);
      return SkImageFilters::MatrixTransform(
          matrix_filter->matrix(), ToSk(matrix_filter->sampling()), nullptr);
    }
    case DlImageFilterType::kCompose: {
      const DlComposeImageFilter* compose_filter = filter->asCompose();
      FML_DCHECK(compose_filter != nullptr);
      return SkImageFilters::Compose(ToSk(compose_filter->outer()),
                                     ToSk(compose_filter->inner()));
    }
    case DlImageFilterType::kColorFilter: {
      const DlColorFilterImageFilter* cf_filter = filter->asColorFilter();
      FML_DCHECK(cf_filter != nullptr);
      return SkImageFilters::ColorFilter(ToSk(cf_filter->color_filter()),
                                         nullptr);
    }
    case DlImageFilterType::kLocalMatrix: {
      const DlLocalMatrixImageFilter* lm_filter = filter->asLocalMatrix();
      FML_DCHECK(lm_filter != nullptr);
      sk_sp<SkImageFilter> skia_filter = ToSk(lm_filter->image_filter());
      // The image_filter property itself might have been null, or the
      // construction of the SkImageFilter might be optimized to null
      // for any number of reasons. In any case, if the filter is null
      // or optimizaed away, let's then optimize away this local matrix
      // case by returning null.
      if (!skia_filter) {
        return nullptr;
      }
      return skia_filter->makeWithLocalMatrix(lm_filter->matrix());
    }
  }
}

ToSk() [9/29]

sk_sp< SkMaskFilter > flutter::ToSk ( const DlMaskFilter &  filter )

inline

Definition at line 113 of file dl_sk_conversions.h.

                                                            {
  return ToSk(&filter);
}

ToSk() [10/29]

sk_sp< SkMaskFilter > flutter::ToSk

(

const DlMaskFilter *

filter

)

Definition at line 262 of file dl_sk_conversions.cc.

                                                     {
  if (!filter) {
    return nullptr;
  }
  switch (filter->type()) {
    case DlMaskFilterType::kBlur: {
      const DlBlurMaskFilter* blur_filter = filter->asBlur();
      FML_DCHECK(blur_filter != nullptr);
      return SkMaskFilter::MakeBlur(ToSk(blur_filter->style()),
                                    blur_filter->sigma(),
                                    blur_filter->respectCTM());
    }
  }
}

ToSk() [11/29]

SkPaint flutter::ToSk

(

const DlPaint &

paint

)

Definition at line 22 of file dl_sk_conversions.cc.

                                   {
  SkPaint sk_paint;
 
  sk_paint.setAntiAlias(paint.isAntiAlias());
  sk_paint.setColor(ToSk(paint.getColor()));
  sk_paint.setBlendMode(ToSk(paint.getBlendMode()));
  sk_paint.setStyle(ToSk(paint.getDrawStyle()));
  sk_paint.setStrokeWidth(paint.getStrokeWidth());
  sk_paint.setStrokeMiter(paint.getStrokeMiter());
  sk_paint.setStrokeCap(ToSk(paint.getStrokeCap()));
  sk_paint.setStrokeJoin(ToSk(paint.getStrokeJoin()));
  sk_paint.setImageFilter(ToSk(paint.getImageFilterPtr()));
  auto color_filter = ToSk(paint.getColorFilterPtr());
  if (paint.isInvertColors()) {
    auto invert_filter = SkColorFilters::Matrix(kInvertColorMatrix);
    if (color_filter) {
      invert_filter = invert_filter->makeComposed(color_filter);
    }
    color_filter = invert_filter;
  }
  sk_paint.setColorFilter(color_filter);
 
  auto color_source = paint.getColorSourcePtr();
  if (color_source) {
    // Unconditionally set dither to true for gradient shaders.
    sk_paint.setDither(color_source->isGradient());
    sk_paint.setShader(ToSk(color_source));
  }
 
  sk_paint.setMaskFilter(ToSk(paint.getMaskFilterPtr()));
 
  return sk_paint;
}

ToSk() [12/29]

sk_sp< SkVertices > flutter::ToSk ( const DlVertices &  vertices )

inline

Definition at line 122 of file dl_sk_conversions.h.

                                                          {
  return ToSk(&vertices);
}

ToSk() [13/29]

sk_sp< SkVertices > flutter::ToSk

(

const DlVertices *

vertices

)

Definition at line 277 of file dl_sk_conversions.cc.

                                                   {
  const SkColor* sk_colors =
      reinterpret_cast<const SkColor*>(vertices->colors());
  return SkVertices::MakeCopy(ToSk(vertices->mode()), vertices->vertex_count(),
                              vertices->vertices(),
                              vertices->texture_coordinates(), sk_colors,
                              vertices->index_count(), vertices->indices());
}

ToSk() [14/29]

sk_sp< SkColorFilter > flutter::ToSk ( const std::shared_ptr< const DlColorFilter > &  filter )

inline

Definition at line 100 of file dl_sk_conversions.h.

                                                      {
  return ToSk(filter.get());
}

ToSk() [15/29]

sk_sp< SkShader > flutter::ToSk ( const std::shared_ptr< const DlColorSource > &  source )

inline

Definition at line 82 of file dl_sk_conversions.h.

                                                      {
  return ToSk(source.get());
}

ToSk() [16/29]

sk_sp< SkImageFilter > flutter::ToSk ( const std::shared_ptr< const DlImageFilter > &  filter )

inline

Definition at line 91 of file dl_sk_conversions.h.

                                                      {
  return ToSk(filter.get());
}

ToSk() [17/29]

sk_sp< SkMaskFilter > flutter::ToSk ( const std::shared_ptr< const DlMaskFilter > &  filter )

inline

Definition at line 109 of file dl_sk_conversions.h.

                                                     {
  return ToSk(filter.get());
}

ToSk() [18/29]

sk_sp< SkVertices > flutter::ToSk ( const std::shared_ptr< const DlVertices > &  vertices )

inline

Definition at line 118 of file dl_sk_conversions.h.

                                                     {
  return ToSk(vertices.get());
}

ToSk() [19/29]

SkBlendMode flutter::ToSk ( DlBlendMode  mode )

inline

Definition at line 17 of file dl_sk_conversions.h.

                                          {
  return static_cast<SkBlendMode>(mode);
}

ToSk() [20/29]

SkClipOp flutter::ToSk ( DlCanvas::ClipOp  op )

inline

Definition at line 73 of file dl_sk_conversions.h.

                                        {
  return static_cast<SkClipOp>(op);
}

ToSk() [21/29]

SkCanvas::PointMode flutter::ToSk ( DlCanvas::PointMode  mode )

inline

Definition at line 77 of file dl_sk_conversions.h.

                                                      {
  return static_cast<SkCanvas::PointMode>(mode);
}

ToSk() [22/29]

SkCanvas::SrcRectConstraint flutter::ToSk ( DlCanvas::SrcRectConstraint  constraint )

inline

Definition at line 68 of file dl_sk_conversions.h.

                                          {
  return static_cast<SkCanvas::SrcRectConstraint>(constraint);
}

ToSk() [23/29]

SkColor flutter::ToSk ( DlColor  color )

inline

Definition at line 21 of file dl_sk_conversions.h.

                                   {
  // This is safe because both SkColor and DlColor are backed by ARGB uint32_t.
  // See dl_sk_conversions_unittests.cc.
  return reinterpret_cast<SkColor&>(color);
}

ToSk() [24/29]

SkPaint::Style flutter::ToSk ( DlDrawStyle  style )

inline

Definition at line 27 of file dl_sk_conversions.h.

                                            {
  return static_cast<SkPaint::Style>(style);
}

ToSk() [25/29]

SkSamplingOptions flutter::ToSk ( DlImageSampling  sampling )

inline

Definition at line 55 of file dl_sk_conversions.h.

                                                        {
  switch (sampling) {
    case DlImageSampling::kCubic:
      return SkSamplingOptions(SkCubicResampler{1 / 3.0f, 1 / 3.0f});
    case DlImageSampling::kLinear:
      return SkSamplingOptions(SkFilterMode::kLinear);
    case DlImageSampling::kMipmapLinear:
      return SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kLinear);
    case DlImageSampling::kNearestNeighbor:
      return SkSamplingOptions(SkFilterMode::kNearest);
  }
}

ToSk() [26/29]

SkPaint::Cap flutter::ToSk ( DlStrokeCap  cap )

inline

Definition at line 31 of file dl_sk_conversions.h.

                                        {
  return static_cast<SkPaint::Cap>(cap);
}

ToSk() [27/29]

SkPaint::Join flutter::ToSk ( DlStrokeJoin  join )

inline

Definition at line 35 of file dl_sk_conversions.h.

                                           {
  return static_cast<SkPaint::Join>(join);
}

ToSk() [28/29]

SkTileMode flutter::ToSk ( DlTileMode  dl_mode )

inline

Definition at line 39 of file dl_sk_conversions.h.

                                           {
  return static_cast<SkTileMode>(dl_mode);
}

ToSk() [29/29]

SkVertices::VertexMode flutter::ToSk ( DlVertexMode  dl_mode )

inline

Definition at line 51 of file dl_sk_conversions.h.

                                                       {
  return static_cast<SkVertices::VertexMode>(dl_mode);
}

ToSkISize()

const SkISize & flutter::ToSkISize ( const DlISize &  size )

inline

Definition at line 75 of file dl_geometry_types.h.

                                                     {
  return *reinterpret_cast<const SkISize*>(&size);
}

ToSkM44() [1/2]

constexpr SkM44 flutter::ToSkM44 ( const DlMatrix &  matrix )

inlineconstexpr

Definition at line 85 of file dl_geometry_types.h.

                                                       {
  return SkM44::ColMajor(matrix.m);
}

ToSkM44() [2/2]

SkM44 flutter::ToSkM44

(

const tonic::Float64List &

matrix4

)

Definition at line 21 of file matrix.cc.

                                               {
  // clang-format off
  return SkM44(
    SafeNarrow(matrix4[ 0]), SafeNarrow(matrix4[ 4]), SafeNarrow(matrix4[ 8]), SafeNarrow(matrix4[12]),
    SafeNarrow(matrix4[ 1]), SafeNarrow(matrix4[ 5]), SafeNarrow(matrix4[ 9]), SafeNarrow(matrix4[13]),
    SafeNarrow(matrix4[ 2]), SafeNarrow(matrix4[ 6]), SafeNarrow(matrix4[10]), SafeNarrow(matrix4[14]),
    SafeNarrow(matrix4[ 3]), SafeNarrow(matrix4[ 7]), SafeNarrow(matrix4[11]), SafeNarrow(matrix4[15])
  );
  // clang-format on
}

ToSkMatrix() [1/2]

constexpr SkMatrix flutter::ToSkMatrix ( const DlMatrix &  matrix )

inlineconstexpr

Definition at line 79 of file dl_geometry_types.h.

                                                             {
  return SkMatrix::MakeAll(matrix.m[0], matrix.m[4], matrix.m[12],  //
                           matrix.m[1], matrix.m[5], matrix.m[13],  //
                           matrix.m[3], matrix.m[7], matrix.m[15]);
}

ToSkMatrix() [2/2]

SkMatrix flutter::ToSkMatrix

(

const tonic::Float64List &

matrix4

)

Definition at line 32 of file matrix.cc.

                                                     {
  FML_DCHECK(matrix4.data());
  SkMatrix sk_matrix;
  for (int i = 0; i < 9; ++i) {
    int matrix4_index = kSkMatrixIndexToMatrix4Index[i];
    if (matrix4_index < matrix4.num_elements()) {
      sk_matrix[i] = SafeNarrow(matrix4[matrix4_index]);
    } else {
      sk_matrix[i] = 0.0f;
    }
  }
  return sk_matrix;
}

ToSkPoint()

const SkPoint & flutter::ToSkPoint ( const DlPoint &  point )

inline

Definition at line 67 of file dl_geometry_types.h.

                                                      {
  return *reinterpret_cast<const SkPoint*>(&point);
}

ToSkRect()

const SkRect & flutter::ToSkRect ( const DlRect &  rect )

inline

Definition at line 71 of file dl_geometry_types.h.

                                                  {
  return *reinterpret_cast<const SkRect*>(&rect);
}

ToStrokedSk()

SkPaint flutter::ToStrokedSk

(

const DlPaint &

paint

)

Definition at line 56 of file dl_sk_conversions.cc.

                                          {
  DlPaint stroked_paint = paint;
  stroked_paint.setDrawStyle(DlDrawStyle::kStroke);
  return ToSk(stroked_paint);
}

TransformedSurfaceSize()

static SkISize flutter::TransformedSurfaceSize ( const SkISize &  size, const SkMatrix &  transformation  )

static

Definition at line 18 of file embedder_external_view.cc.

                                                                      {
  const auto source_rect = SkRect::MakeWH(size.width(), size.height());
  const auto transformed_rect = transformation.mapRect(source_rect);
  return SkISize::Make(transformed_rect.width(), transformed_rect.height());
}

UnblockSIGPROF()

static void flutter::UnblockSIGPROF ( )

static

Definition at line 325 of file tester_main.cc.

                             {
#if defined(FML_OS_POSIX)
  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, SIGPROF);
  pthread_sigmask(SIG_UNBLOCK, &set, NULL);
#endif  // defined(FML_OS_POSIX)
}

UndeadChar()

uint32_t flutter::UndeadChar ( uint32_t  ch )

inline

Definition at line 34 of file keyboard_utils.h.

                                        {
  return ch & ~kDeadKeyCharMask;
}

Unit() [1/2]

flutter::Unit

(

benchmark::kMicrosecond

)

Unit() [2/2]

flutter::Unit

(

benchmark::kNanosecond

)

UnregisterTexture()

static void flutter::UnregisterTexture ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder, jlong  texture_id  )

static

Definition at line 509 of file platform_view_android_jni_impl.cc.

                                                {
  ANDROID_SHELL_HOLDER->GetPlatformView()->UnregisterTexture(
      static_cast<int64_t>(texture_id));
}

UnsafeUploadTextureToPrivate()

static std::pair< sk_sp< DlImage >, std::string > flutter::UnsafeUploadTextureToPrivate ( const std::shared_ptr< impeller::Context > &  context, const std::shared_ptr< impeller::DeviceBuffer > &  buffer, const SkImageInfo &  image_info  )

static

Only call this method if the GPU is available.

Definition at line 257 of file image_decoder_impeller.cc.

                                   {
  const auto pixel_format =
      impeller::skia_conversions::ToPixelFormat(image_info.colorType());
  if (!pixel_format) {
    std::string decode_error(impeller::SPrintF(
        "Unsupported pixel format (SkColorType=%d)", image_info.colorType()));
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
 
  impeller::TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = impeller::StorageMode::kDevicePrivate;
  texture_descriptor.format = pixel_format.value();
  texture_descriptor.size = {image_info.width(), image_info.height()};
  texture_descriptor.mip_count = texture_descriptor.size.MipCount();
  texture_descriptor.compression_type = impeller::CompressionType::kLossy;
 
  auto dest_texture =
      context->GetResourceAllocator()->CreateTexture(texture_descriptor);
  if (!dest_texture) {
    std::string decode_error("Could not create Impeller texture.");
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
 
  dest_texture->SetLabel(
      impeller::SPrintF("ui.Image(%p)", dest_texture.get()).c_str());
 
  auto command_buffer = context->CreateCommandBuffer();
  if (!command_buffer) {
    std::string decode_error(
        "Could not create command buffer for mipmap generation.");
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
  command_buffer->SetLabel("Mipmap Command Buffer");
 
  auto blit_pass = command_buffer->CreateBlitPass();
  if (!blit_pass) {
    std::string decode_error(
        "Could not create blit pass for mipmap generation.");
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
  blit_pass->SetLabel("Mipmap Blit Pass");
  blit_pass->AddCopy(impeller::DeviceBuffer::AsBufferView(buffer),
                     dest_texture);
  if (texture_descriptor.size.MipCount() > 1) {
    blit_pass->GenerateMipmap(dest_texture);
  }
 
  blit_pass->EncodeCommands(context->GetResourceAllocator());
  if (!context->GetCommandQueue()->Submit({command_buffer}).ok()) {
    std::string decode_error("Failed to submit blit pass command buffer.");
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
 
  return std::make_pair(
      impeller::DlImageImpeller::Make(std::move(dest_texture)), std::string());
}

UpdateDisplayMetrics()

static void flutter::UpdateDisplayMetrics ( JNIEnv *  env, jobject  jcaller, jlong  shell_holder  )

static

Definition at line 367 of file platform_view_android_jni_impl.cc.

                                                     {
  ANDROID_SHELL_HOLDER->UpdateDisplayMetrics();
}

UpdateJavaAssetManager()

static void flutter::UpdateJavaAssetManager ( JNIEnv *  env, jobject  obj, jlong  shell_holder, jobject  jAssetManager, jstring  jAssetBundlePath  )

static

Definition at line 643 of file platform_view_android_jni_impl.cc.

                                                             {
  auto asset_resolver = std::make_unique<flutter::APKAssetProvider>(
      env,                                                   // jni environment
      jAssetManager,                                         // asset manager
      fml::jni::JavaStringToString(env, jAssetBundlePath));  // apk asset dir
 
  ANDROID_SHELL_HOLDER->GetPlatformView()->UpdateAssetResolverByType(
      std::move(asset_resolver),
      AssetResolver::AssetResolverType::kApkAssetProvider);
}

UploadRasterImage()

static SkiaGPUObject< SkImage > flutter::UploadRasterImage ( sk_sp< SkImage >  image, const fml::WeakPtr< IOManager > &  io_manager, const fml::tracing::TraceFlow &  flow  )

static

Definition at line 164 of file image_decoder_skia.cc.

                                     {
  TRACE_EVENT0("flutter", __FUNCTION__);
  flow.Step(__FUNCTION__);
 
  // Should not already be a texture image because that is the entire point of
  // the this method.
  FML_DCHECK(!image->isTextureBacked());
 
  if (!io_manager->GetResourceContext() || !io_manager->GetSkiaUnrefQueue()) {
    FML_LOG(ERROR)
        << "Could not acquire context of release queue for texture upload.";
    return {};
  }
 
  SkPixmap pixmap;
  if (!image->peekPixels(&pixmap)) {
    FML_LOG(ERROR) << "Could not peek pixels of image for texture upload.";
    return {};
  }
 
  SkiaGPUObject<SkImage> result;
  io_manager->GetIsGpuDisabledSyncSwitch()->Execute(
      fml::SyncSwitch::Handlers()
          .SetIfTrue([&result, &pixmap, &image] {
            SkSafeRef(image.get());
            sk_sp<SkImage> texture_image = SkImages::RasterFromPixmap(
                pixmap,
                [](const void* pixels, SkImages::ReleaseContext context) {
                  SkSafeUnref(static_cast<SkImage*>(context));
                },
                image.get());
            result = {std::move(texture_image), nullptr};
          })
          .SetIfFalse([&result, context = io_manager->GetResourceContext(),
                       &pixmap, queue = io_manager->GetSkiaUnrefQueue()] {
            TRACE_EVENT0("flutter", "MakeCrossContextImageFromPixmap");
            sk_sp<SkImage> texture_image =
                SkImages::CrossContextTextureFromPixmap(
                    context.get(),  // context
                    pixmap,         // pixmap
                    true,           // buildMips,
                    true            // limitToMaxTextureSize
                );
            if (!texture_image) {
              FML_LOG(ERROR) << "Could not make x-context image.";
              result = {};
            } else {
              result = {std::move(texture_image), queue};
            }
          }));
 
  return result;
}

ValidNumTextures()

static bool flutter::ValidNumTextures ( int  expected, int  actual  )

static

Definition at line 17 of file embedder_external_texture_metal.mm.

                                                       {
  if (expected == actual) {
    return true;
  } else {
    FML_LOG(ERROR) << "Invalid number of textures, expected: " << expected << ", got: " << actual;
    return false;
  }
}

VectorToSize()

static FlutterSize flutter::VectorToSize ( const SkVector &  vector )

static

Definition at line 92 of file embedder_layers.cc.

                                                        {
  FlutterSize size = {};
  size.width = vector.x();
  size.height = vector.y();
  return size;
}

WindowsPlatformThreadPrioritySetter()

static void flutter::WindowsPlatformThreadPrioritySetter ( FlutterThreadPriority  priority )

static

Definition at line 60 of file flutter_windows_engine.h.

                                    {
  // TODO(99502): Add support for tracing to the windows embedding so we can
  // mark thread priorities and success/failure.
  switch (priority) {
    case FlutterThreadPriority::kBackground: {
      SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
      break;
    }
    case FlutterThreadPriority::kDisplay: {
      SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
      break;
    }
    case FlutterThreadPriority::kRaster: {
      SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
      break;
    }
    case FlutterThreadPriority::kNormal: {
      // For normal or default priority we do not need to set the priority
      // class.
      break;
    }
  }
}

WrapOnscreenSurface()

static sk_sp< SkSurface > flutter::WrapOnscreenSurface ( GrDirectContext *  context, const SkISize &  size, intptr_t  fbo  )

static

Definition at line 134 of file gpu_surface_gl_skia.cc.

                                                          {
  GrGLenum format = kUnknown_SkColorType;
  const SkColorType color_type = FirstSupportedColorType(context, &format);
 
  GrGLFramebufferInfo framebuffer_info = {};
  framebuffer_info.fFBOID = static_cast<GrGLuint>(fbo);
  framebuffer_info.fFormat = format;
 
  auto render_target =
      GrBackendRenderTargets::MakeGL(size.width(),     // width
                                     size.height(),    // height
                                     0,                // sample count
                                     0,                // stencil bits
                                     framebuffer_info  // framebuffer info
      );
 
  sk_sp<SkColorSpace> colorspace = SkColorSpace::MakeSRGB();
  SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
 
  return SkSurfaces::WrapBackendRenderTarget(
      context,                                       // Gr context
      render_target,                                 // render target
      GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,  // origin
      color_type,                                    // color type
      colorspace,                                    // colorspace
      &surface_props                                 // surface properties
  );
}

WriteServerErrorResponse()

static void flutter::WriteServerErrorResponse ( rapidjson::Document *  document, const char *  message  )

static

Definition at line 104 of file service_protocol.cc.

                                                          {
  document->SetObject();
  document->AddMember("code", -32000, document->GetAllocator());
  rapidjson::Value message_value;
  message_value.SetString(message, document->GetAllocator());
  document->AddMember("message", message_value, document->GetAllocator());
}

Variable Documentation

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 flutter::allowlist

Definition at line 171 of file switches.h.

backends

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 flutter::backends

Definition at line 276 of file switches.h.

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 flutter::buffer

Definition at line 126 of file switches.h.

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 flutter::cache

Definition at line 191 of file switches.h.

canApplyBlurBackdrop

BOOL flutter::canApplyBlurBackdrop = YES

Definition at line 80 of file FlutterPlatformViews.mm.

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 flutter::compilation

Definition at line 180 of file switches.h.

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 flutter::counts

Definition at line 239 of file switches.h.

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 flutter::dart

Definition at line 215 of file switches.h.

dart_plugin_registrant_library_override

const char * flutter::dart_plugin_registrant_library_override = nullptr

The name of the library where the Dart Plugin Registrant will be looked for. This is available for testing.

Definition at line 16 of file dart_plugin_registrant.cc.

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 flutter::data

Definition at line 41 of file switches.h.

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 flutter::default

Definition at line 183 of file switches.h.

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 flutter::dir

Definition at line 145 of file switches.h.

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 flutter::example

Definition at line 128 of file switches.h.

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 flutter::fallback

Definition at line 154 of file switches.h.

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 flutter::file

Definition at line 201 of file switches.h.

flow_type [1/2]

const auto* flutter::flow_type = "RasterCacheFlow::DisplayList"

static

Definition at line 144 of file display_list_raster_cache_item.cc.

flow_type [2/2]

const auto* flutter::flow_type = "RasterCacheFlow::Layer"

static

Definition at line 140 of file layer_raster_cache_item.cc.

fonts

it will be possible to load the file into Perfetto s trace viewer disable asset flutter::fonts

Definition at line 213 of file switches.h.

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 flutter::forever

Definition at line 227 of file switches.h.

format

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 flutter::format

Definition at line 203 of file switches.h.

g_acquire_latest_image_method

jmethodID flutter::g_acquire_latest_image_method = nullptr

static

Definition at line 121 of file platform_view_android_jni_impl.cc.

g_async_wait_for_vsync_method_

jmethodID flutter::g_async_wait_for_vsync_method_ = nullptr

static

Definition at line 21 of file vsync_waiter_android.cc.

g_attach_to_gl_context_method

jmethodID flutter::g_attach_to_gl_context_method = nullptr

static

Definition at line 111 of file platform_view_android_jni_impl.cc.

g_bitmap_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_bitmap_class = nullptr

static

Definition at line 62 of file platform_view_android_jni_impl.cc.

g_bitmap_config_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_bitmap_config_class = nullptr

static

Definition at line 64 of file platform_view_android_jni_impl.cc.

g_bitmap_config_value_of

jmethodID flutter::g_bitmap_config_value_of = nullptr

static

Definition at line 148 of file platform_view_android_jni_impl.cc.

g_bitmap_copy_pixels_from_buffer_method

jmethodID flutter::g_bitmap_copy_pixels_from_buffer_method = nullptr

static

Definition at line 146 of file platform_view_android_jni_impl.cc.

g_bitmap_create_bitmap_method

jmethodID flutter::g_bitmap_create_bitmap_method = nullptr

static

Definition at line 144 of file platform_view_android_jni_impl.cc.

g_compute_platform_resolved_locale_method

jmethodID flutter::g_compute_platform_resolved_locale_method = nullptr

static

Definition at line 129 of file platform_view_android_jni_impl.cc.

g_create_overlay_surface_method

jmethodID flutter::g_create_overlay_surface_method = nullptr

static

Definition at line 101 of file platform_view_android_jni_impl.cc.

g_decode_image_method

jmethodID flutter::g_decode_image_method = nullptr

static

Definition at line 20 of file android_image_generator.cc.

g_destroy_overlay_surfaces_method

jmethodID flutter::g_destroy_overlay_surfaces_method = nullptr

static

Definition at line 103 of file platform_view_android_jni_impl.cc.

g_detach_from_gl_context_method

jmethodID flutter::g_detach_from_gl_context_method = nullptr

static

Definition at line 119 of file platform_view_android_jni_impl.cc.

g_flutter_callback_info_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_flutter_callback_info_class

static

Initial value:

=
    nullptr

Definition at line 43 of file platform_view_android_jni_impl.cc.

g_flutter_callback_info_constructor

jmethodID flutter::g_flutter_callback_info_constructor = nullptr

static

Definition at line 68 of file platform_view_android_jni_impl.cc.

g_flutter_jni_class [1/2]

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_flutter_jni_class = nullptr

static

Definition at line 19 of file android_image_generator.cc.

g_flutter_jni_class [2/2]

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_flutter_jni_class = nullptr

static

Definition at line 46 of file platform_view_android_jni_impl.cc.

g_flutter_main

std::unique_ptr<FlutterMain> flutter::g_flutter_main

static

Definition at line 56 of file flutter_main.cc.

g_get_scaled_font_size_method

jmethodID flutter::g_get_scaled_font_size_method = nullptr

static

Definition at line 95 of file platform_view_android_jni_impl.cc.

g_get_transform_matrix_method

jmethodID flutter::g_get_transform_matrix_method = nullptr

static

Definition at line 117 of file platform_view_android_jni_impl.cc.

g_handle_platform_message_method

jmethodID flutter::g_handle_platform_message_method = nullptr

static

Definition at line 87 of file platform_view_android_jni_impl.cc.

g_handle_platform_message_response_method

jmethodID flutter::g_handle_platform_message_response_method = nullptr

static

Definition at line 89 of file platform_view_android_jni_impl.cc.

g_hardware_buffer_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_hardware_buffer_class = nullptr

static

Definition at line 58 of file platform_view_android_jni_impl.cc.

g_hardware_buffer_close_method

jmethodID flutter::g_hardware_buffer_close_method = nullptr

static

Definition at line 127 of file platform_view_android_jni_impl.cc.

g_image_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_image_class = nullptr

static

Definition at line 56 of file platform_view_android_jni_impl.cc.

g_image_close_method

jmethodID flutter::g_image_close_method = nullptr

static

Definition at line 125 of file platform_view_android_jni_impl.cc.

g_image_consumer_texture_registry_interface

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_image_consumer_texture_registry_interface = nullptr

static

Definition at line 54 of file platform_view_android_jni_impl.cc.

g_image_get_hardware_buffer_method

jmethodID flutter::g_image_get_hardware_buffer_method = nullptr

static

Definition at line 123 of file platform_view_android_jni_impl.cc.

g_java_long_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_java_long_class = nullptr

static

Definition at line 60 of file platform_view_android_jni_impl.cc.

g_java_weak_reference_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_java_weak_reference_class

static

Initial value:

=
    nullptr

Definition at line 48 of file platform_view_android_jni_impl.cc.

g_java_weak_reference_get_method

jmethodID flutter::g_java_weak_reference_get_method = nullptr

static

Definition at line 109 of file platform_view_android_jni_impl.cc.

g_jni_constructor

jmethodID flutter::g_jni_constructor = nullptr

static

Definition at line 83 of file platform_view_android_jni_impl.cc.

g_jni_shell_holder_field

jfieldID flutter::g_jni_shell_holder_field = nullptr

static

Definition at line 81 of file platform_view_android_jni_impl.cc.

g_long_constructor

jmethodID flutter::g_long_constructor = nullptr

static

Definition at line 85 of file platform_view_android_jni_impl.cc.

g_mutators_stack_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_mutators_stack_class = nullptr

static

Definition at line 151 of file platform_view_android_jni_impl.cc.

g_mutators_stack_init_method

jmethodID flutter::g_mutators_stack_init_method = nullptr

static

Definition at line 152 of file platform_view_android_jni_impl.cc.

g_mutators_stack_push_cliprect_method

jmethodID flutter::g_mutators_stack_push_cliprect_method = nullptr

static

Definition at line 154 of file platform_view_android_jni_impl.cc.

g_mutators_stack_push_cliprrect_method

jmethodID flutter::g_mutators_stack_push_cliprrect_method = nullptr

static

Definition at line 155 of file platform_view_android_jni_impl.cc.

g_mutators_stack_push_transform_method

jmethodID flutter::g_mutators_stack_push_transform_method = nullptr

static

Definition at line 153 of file platform_view_android_jni_impl.cc.

g_on_begin_frame_method

jmethodID flutter::g_on_begin_frame_method = nullptr

static

Definition at line 105 of file platform_view_android_jni_impl.cc.

g_on_display_overlay_surface_method

jmethodID flutter::g_on_display_overlay_surface_method = nullptr

static

Definition at line 138 of file platform_view_android_jni_impl.cc.

g_on_display_platform_view_method

jmethodID flutter::g_on_display_platform_view_method = nullptr

static

Definition at line 134 of file platform_view_android_jni_impl.cc.

g_on_end_frame_method

jmethodID flutter::g_on_end_frame_method = nullptr

static

Definition at line 107 of file platform_view_android_jni_impl.cc.

g_on_engine_restart_method

jmethodID flutter::g_on_engine_restart_method = nullptr

static

Definition at line 99 of file platform_view_android_jni_impl.cc.

g_on_first_frame_method

jmethodID flutter::g_on_first_frame_method = nullptr

static

Definition at line 97 of file platform_view_android_jni_impl.cc.

g_overlay_surface_id_method

jmethodID flutter::g_overlay_surface_id_method = nullptr

static

Definition at line 140 of file platform_view_android_jni_impl.cc.

g_overlay_surface_surface_method

jmethodID flutter::g_overlay_surface_surface_method = nullptr

static

Definition at line 142 of file platform_view_android_jni_impl.cc.

g_refresh_rate_

std::atomic_uint flutter::g_refresh_rate_ = 60

static

Definition at line 22 of file vsync_waiter_android.cc.

g_request_dart_deferred_library_method

jmethodID flutter::g_request_dart_deferred_library_method = nullptr

static

Definition at line 131 of file platform_view_android_jni_impl.cc.

g_shell

absl::NoDestructor<std::unique_ptr<Shell> > flutter::g_shell

static

Definition at line 127 of file tester_main.cc.

g_surface_texture_wrapper_should_update

jmethodID flutter::g_surface_texture_wrapper_should_update = nullptr

static

Definition at line 113 of file platform_view_android_jni_impl.cc.

g_texture_wrapper_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_texture_wrapper_class = nullptr

static

Definition at line 51 of file platform_view_android_jni_impl.cc.

g_update_custom_accessibility_actions_method

jmethodID flutter::g_update_custom_accessibility_actions_method = nullptr

static

Definition at line 93 of file platform_view_android_jni_impl.cc.

g_update_semantics_method

jmethodID flutter::g_update_semantics_method = nullptr

static

Definition at line 91 of file platform_view_android_jni_impl.cc.

g_update_tex_image_method

jmethodID flutter::g_update_tex_image_method = nullptr

static

Definition at line 115 of file platform_view_android_jni_impl.cc.

g_vsync_waiter_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_vsync_waiter_class = nullptr

static

Definition at line 20 of file vsync_waiter_android.cc.

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 flutter::gc

Definition at line 238 of file switches.h.

gFontFile

std::string flutter::gFontFile

static

Definition at line 10 of file flow_test_utils.cc.

gGoldenDir

std::string flutter::gGoldenDir

static

Definition at line 9 of file flow_test_utils.cc.

gVM

std::weak_ptr<DartVM> flutter::gVM

static

Definition at line 16 of file dart_vm_lifecycle.cc.

gVMData

std::weak_ptr<const DartVMData> flutter::gVMData

static

Definition at line 25 of file dart_vm_lifecycle.cc.

gVMDependentsMutex

std::mutex flutter::gVMDependentsMutex

static

Definition at line 24 of file dart_vm_lifecycle.cc.

gVMIsolateNameServer

std::weak_ptr<IsolateNameServer> flutter::gVMIsolateNameServer

static

Definition at line 27 of file dart_vm_lifecycle.cc.

gVMLaunchCount

std::atomic_size_t flutter::gVMLaunchCount

static

Definition at line 279 of file dart_vm.cc.

gVMLeak

std::shared_ptr<DartVM>* flutter::gVMLeak

static

Definition at line 17 of file dart_vm_lifecycle.cc.

gVMMutex

std::mutex flutter::gVMMutex

static

Definition at line 15 of file dart_vm_lifecycle.cc.

gVMServiceProtocol

std::weak_ptr<ServiceProtocol> flutter::gVMServiceProtocol

static

Definition at line 26 of file dart_vm_lifecycle.cc.

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 flutter::h

Definition at line 59 of file switches.h.

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 flutter::host

Definition at line 74 of file switches.h.

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 a domain level old gen heap The size limit in megabytes for the Dart VM old gen heap space enable flutter::impeller

Definition at line 266 of file switches.h.

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 flutter::ipv6

Definition at line 118 of file switches.h.

kAccessibilityExpandedChanged

NSString* const flutter::kAccessibilityExpandedChanged = @"@"AXExpandedChanged"

static

Definition at line 20 of file AccessibilityBridgeMac.mm.

kAccessibilityInvalidStatusChangedNotification

NSString* const flutter::kAccessibilityInvalidStatusChangedNotification = @"@"AXInvalidStatusChanged"

static

Definition at line 17 of file AccessibilityBridgeMac.mm.

kAccessibilityLiveRegionChangedNotification

NSString* const flutter::kAccessibilityLiveRegionChangedNotification = @"@"AXLiveRegionChanged"

static

Definition at line 19 of file AccessibilityBridgeMac.mm.

kAccessibilityLiveRegionCreatedNotification

NSString* const flutter::kAccessibilityLiveRegionCreatedNotification = @"@"AXLiveRegionCreated"

static

Definition at line 18 of file AccessibilityBridgeMac.mm.

kAccessibilityLoadCompleteNotification

NSString* const flutter::kAccessibilityLoadCompleteNotification = @"@"AXLoadComplete"

static

Definition at line 16 of file AccessibilityBridgeMac.mm.

kAccessibilityMenuItemSelectedNotification

NSString* const flutter::kAccessibilityMenuItemSelectedNotification = @"@"AXMenuItemSelected"

static

Definition at line 21 of file AccessibilityBridgeMac.mm.

kAssetChannel

constexpr char flutter::kAssetChannel[] = "flutter/assets"

staticconstexpr

Definition at line 27 of file engine.cc.

kBinarySearchThreshold

const int flutter::kBinarySearchThreshold = 10

Definition at line 13 of file dl_region.cc.

kBlendModeDefault

constexpr uint32_t flutter::kBlendModeDefault

constexpr

Initial value:

=
    static_cast<uint32_t>(SkBlendMode::kSrcOver)

Definition at line 51 of file paint.cc.

kBlendModeIndex

constexpr int flutter::kBlendModeIndex = 2

constexpr

Definition at line 26 of file paint.cc.

kBytesPerField

constexpr int flutter::kBytesPerField = sizeof(int64_t)

staticconstexpr

Definition at line 20 of file pointer_data.cc.

kBytesPerKeyField

constexpr int flutter::kBytesPerKeyField = sizeof(int64_t)

staticconstexpr

Definition at line 17 of file key_data.h.

kCacheName

const char* flutter::kCacheName = "flutter_callback_cache.json"

static

Definition at line 30 of file callback_cache.cc.

kCapsLockLogicalKey

const uint64_t flutter::kCapsLockLogicalKey = 0x100000104

The logical key for CapsLock, which needs special handling.

Definition at line 246 of file KeyCodeMap.g.mm.

kCapsLockPhysicalKey

const uint64_t flutter::kCapsLockPhysicalKey = 0x00070039

The physical key for CapsLock, which needs special handling.

Definition at line 245 of file KeyCodeMap.g.mm.

kClassNameKey

const char* flutter::kClassNameKey = "class_name"

static

Definition at line 28 of file callback_cache.cc.

kColorDefault

constexpr uint32_t flutter::kColorDefault = 0xFF000000

constexpr

Definition at line 48 of file paint.cc.

kColorFilterIndex

constexpr int flutter::kColorFilterIndex = 1

constexpr

Definition at line 43 of file paint.cc.

kColorIndex

constexpr int flutter::kColorIndex = 1

constexpr

Definition at line 25 of file paint.cc.

kControl

constexpr int flutter::kControl = 1 << 3

constexpr

Definition at line 15 of file keyboard_utils.h.

kDartAllConfigsArgs

const char* flutter::kDartAllConfigsArgs[]

static

Initial value:

= {
    
    "--enable_mirrors=false",
    "--background_compilation",
    
    
    
}

Definition at line 53 of file dart_vm.cc.

kDartAssertArgs

const char* flutter::kDartAssertArgs[]

static

Initial value:

= {
    
    "--enable_asserts",
    
}

Definition at line 84 of file dart_vm.cc.

kDartDefaultTraceStreamsArgs

FML_ALLOW_UNUSED_TYPE const char* flutter::kDartDefaultTraceStreamsArgs[]

static

Initial value:

{
    "--timeline_streams=Dart,Embedder,GC",
}

Definition at line 109 of file dart_vm.cc.

kDartDisableIntegerDivisionArgs

FML_ALLOW_UNUSED_TYPE const char* flutter::kDartDisableIntegerDivisionArgs[]

static

Initial value:

= {
    "--no_use_integer_division",
}

Definition at line 80 of file dart_vm.cc.

kDartEndlessTraceBufferArgs

const char* flutter::kDartEndlessTraceBufferArgs[]

static

Initial value:

{
    "--timeline_recorder=endless",
}

Definition at line 94 of file dart_vm.cc.

kDartPrecompilationArgs

const char* flutter::kDartPrecompilationArgs[] = {"--precompilation"}

static

Definition at line 62 of file dart_vm.cc.

kDartStartPausedArgs

const char* flutter::kDartStartPausedArgs[]

static

Initial value:

{
    "--pause_isolates_on_start",
}

Definition at line 90 of file dart_vm.cc.

kDartStartupTraceStreamsArgs

const char* flutter::kDartStartupTraceStreamsArgs[]

static

Initial value:

{
    "--timeline_streams=Compiler,Dart,Debugger,Embedder,GC,Isolate,VM,API",
}

Definition at line 113 of file dart_vm.cc.

kDartSystraceTraceBufferArgs

const char* flutter::kDartSystraceTraceBufferArgs[]

static

Initial value:

= {
    "--timeline_recorder=systrace",
}

Definition at line 98 of file dart_vm.cc.

kDartSystraceTraceStreamsArgs

const char* flutter::kDartSystraceTraceStreamsArgs[]

static

Initial value:

= {
    "--timeline_streams=Compiler,Dart,Debugger,Embedder,GC,Isolate,VM,API",
}

Definition at line 117 of file dart_vm.cc.

kDartWrapperInfoUIImage

const tonic::DartWrapperInfo flutter::kDartWrapperInfoUIImage("ui", "_Image") ( "ui"  , "_Image"    )

static

kDartWriteProtectCodeArgs

FML_ALLOW_UNUSED_TYPE const char* flutter::kDartWriteProtectCodeArgs[]

static

Initial value:

= {
    "--no_write_protect_code",
}

Definition at line 75 of file dart_vm.cc.

kDataByteCount

constexpr size_t flutter::kDataByteCount = 52

constexpr

Definition at line 37 of file paint.cc.

kDeadKeyCharMask

constexpr int flutter::kDeadKeyCharMask = 0x80000000

constexpr

Definition at line 30 of file keyboard_utils.h.

kDisplayEngineStatistics

const int flutter::kDisplayEngineStatistics = 1 << 2

Definition at line 20 of file performance_overlay_layer.h.

kDisplayRasterizerStatistics

const int flutter::kDisplayRasterizerStatistics = 1 << 0

Definition at line 18 of file performance_overlay_layer.h.

kEmpty [1/2]

constexpr DlRect flutter::kEmpty = DlRect()

staticconstexpr

Definition at line 117 of file dl_builder.cc.

kEmpty [2/2]

constexpr DlRect flutter::kEmpty = DlRect()

staticconstexpr

Definition at line 21 of file dl_matrix_clip_tracker.cc.

kExitTypeNames

constexpr const char* flutter::kExitTypeNames[]

staticconstexpr

Initial value:

= {
    PlatformHandler::kExitTypeRequired, PlatformHandler::kExitTypeCancelable}

Definition at line 398 of file platform_handler.cc.

keyCodeToLogicalKey

const NSDictionary * flutter::keyCodeToLogicalKey

A map from macOS key codes to Flutter's logical key values.

This is used to derive logical keys that can't or shouldn't be derived from |charactersIgnoringModifiers|.

Definition at line 149 of file KeyCodeMap.g.mm.

keyCodeToModifierFlag

const NSDictionary * flutter::keyCodeToModifierFlag

Initial value:

= @{
  @0x00000038 : @(kModifierFlagShiftLeft),
  @0x0000003c : @(kModifierFlagShiftRight),
  @0x0000003b : @(kModifierFlagControlLeft),
  @0x0000003e : @(kModifierFlagControlRight),
  @0x0000003a : @(kModifierFlagAltLeft),
  @0x0000003d : @(kModifierFlagAltRight),
  @0x00000037 : @(kModifierFlagMetaLeft),
  @0x00000036 : @(kModifierFlagMetaRight),
}

Map |NSEvent.keyCode| to its corresponding bitmask of NSEventModifierFlags.

This does not include CapsLock, for it is handled specially.

Definition at line 223 of file KeyCodeMap.g.mm.

keyCodeToPhysicalKey

const NSDictionary * flutter::keyCodeToPhysicalKey

Maps macOS-specific key code values representing |PhysicalKeyboardKey|.

MacOS doesn't provide a scan code, but a virtual keycode to represent a physical key.

Definition at line 26 of file KeyCodeMap.g.mm.

kFileUriPrefix

constexpr char flutter::kFileUriPrefix[] = "file://"

constexpr

Definition at line 127 of file dart_vm.cc.

kFileUriPrefixLength

constexpr size_t flutter::kFileUriPrefixLength = sizeof(kFileUriPrefix) - 1

constexpr

Definition at line 128 of file dart_vm.cc.

kFilterQualities

const std::array<DlImageSampling, 4> flutter::kFilterQualities

static

Initial value:

= {
    DlImageSampling::kNearestNeighbor,
    DlImageSampling::kLinear,
    DlImageSampling::kMipmapLinear,
    DlImageSampling::kCubic,
}

Definition at line 25 of file image_filter.cc.

kFilterQualityIndex

constexpr int flutter::kFilterQualityIndex = 8

constexpr

Definition at line 32 of file paint.cc.

kFlutterImplicitViewId

constexpr int64_t flutter::kFlutterImplicitViewId = 0

constexpr

Definition at line 35 of file constants.h.

kFlutterThreadName

constexpr const char* flutter::kFlutterThreadName = "io.flutter"

constexpr

Definition at line 113 of file embedder_thread_host.cc.

kFontChange

constexpr char flutter::kFontChange[] = "fontsChange"

constexpr

Definition at line 51 of file shell.cc.

kGetPreferredLanguageRegKey

constexpr const wchar_t flutter::kGetPreferredLanguageRegKey[]

constexpr

Initial value:

=
    L"Control panel\\International\\User Profile"

Definition at line 18 of file system_utils.h.

kGetPreferredLanguageRegValue

constexpr const wchar_t flutter::kGetPreferredLanguageRegValue[] = L"Languages"

constexpr

Definition at line 20 of file system_utils.h.

kGiantRect

constexpr SkRect flutter::kGiantRect = SkRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F)

staticconstexpr

Definition at line 50 of file layer.h.

kGrCacheMaxByteSize

const size_t flutter::kGrCacheMaxByteSize = 24 * (1 << 20)

static

Definition at line 41 of file gpu_surface_gl_skia.cc.

kHandleKey

const char* flutter::kHandleKey = "handle"

static

Definition at line 25 of file callback_cache.cc.

kHasScrollingAction

constexpr int flutter::kHasScrollingAction

constexpr

Initial value:

=
    FlutterSemanticsAction::kFlutterSemanticsActionScrollLeft |
    FlutterSemanticsAction::kFlutterSemanticsActionScrollRight |
    FlutterSemanticsAction::kFlutterSemanticsActionScrollUp |
    FlutterSemanticsAction::kFlutterSemanticsActionScrollDown

Definition at line 16 of file accessibility_bridge.cc.

kHorizontalScrollSemanticsActions

const int flutter::kHorizontalScrollSemanticsActions

Initial value:

=
    static_cast<int32_t>(SemanticsAction::kScrollLeft) |
    static_cast<int32_t>(SemanticsAction::kScrollRight)

Definition at line 52 of file semantics_node.h.

kImageFilterIndex

constexpr int flutter::kImageFilterIndex = 2

constexpr

Definition at line 44 of file paint.cc.

kImageReaderSwapchainSize

constexpr size_t flutter::kImageReaderSwapchainSize = 6u

staticconstexpr

Definition at line 20 of file image_lru.h.

kImpellerRepaintRatio

constexpr float flutter::kImpellerRepaintRatio = 0.7f

constexpr

The max ratio of pixel width or height to size that is dirty which results in a partial repaint.

Performing a partial repaint has a small overhead - Impeller needs to allocate a fairly large resolve texture for the root pass instead of using the drawable texture, and a final blit must be performed. At a minimum, if the damage rect is the entire buffer, we must not perform a partial repaint. Beyond that, we could only experimentally determine what this value should be. From looking at the Flutter Gallery, we noticed that there are occassionally small partial repaints which shave off trivial numbers of pixels.

Definition at line 208 of file compositor_context.cc.

kImplicitViewId

static constexpr int64_t flutter::kImplicitViewId = 0

constexpr

Definition at line 55 of file flutter_windows_engine.h.

kInvertColorIndex

constexpr int flutter::kInvertColorIndex = 12

constexpr

Definition at line 36 of file paint.cc.

kInvertColorMatrix

constexpr float flutter::kInvertColorMatrix

constexpr

Initial value:

= {
  -1.0,    0,    0, 1.0, 0,
     0, -1.0,    0, 1.0, 0,
     0,    0, -1.0, 1.0, 0,
   1.0,  1.0,  1.0, 1.0, 0
}

Definition at line 14 of file dl_sk_conversions.cc.

kIsAntiAliasIndex

constexpr int flutter::kIsAntiAliasIndex = 0

constexpr

Definition at line 24 of file paint.cc.

kIsolateChannel

constexpr char flutter::kIsolateChannel[] = "flutter/isolate"

staticconstexpr

Definition at line 32 of file engine.cc.

kKeyCodeControlLeft

constexpr int flutter::kKeyCodeControlLeft = 0xa2

constexpr

Definition at line 21 of file keyboard_utils.h.

kKeyCodeShiftLeft

constexpr int flutter::kKeyCodeShiftLeft = 0xa0

constexpr

Definition at line 18 of file keyboard_utils.h.

kKeyDataFieldCount

constexpr int flutter::kKeyDataFieldCount = 6

staticconstexpr

Definition at line 16 of file key_data.h.

kLayoutGoals

const std::vector< LayoutGoal > flutter::kLayoutGoals

All keys that Flutter wants to derive layout for, and guides on how to derive them.

Definition at line 248 of file KeyCodeMap.g.mm.

kLibraryPathKey

const char* flutter::kLibraryPathKey = "library_path"

static

Definition at line 29 of file callback_cache.cc.

kLifecycleChannel

constexpr char flutter::kLifecycleChannel[] = "flutter/lifecycle"

staticconstexpr

Definition at line 28 of file engine.cc.

kListViewsExtensionName

constexpr std::string_view flutter::kListViewsExtensionName

staticconstexpr

Initial value:

=
    "_flutter.listViews"

Definition at line 47 of file service_protocol.cc.

kLocalizationChannel

constexpr char flutter::kLocalizationChannel[] = "flutter/localization"

staticconstexpr

Definition at line 30 of file engine.cc.

kMacosPlane

const uint64_t flutter::kMacosPlane = 0x01400000000

The plane value for the private keys defined by the macOS embedding.

Definition at line 24 of file KeyCodeMap.g.mm.

kMaskFilterBlurStyleIndex

constexpr int flutter::kMaskFilterBlurStyleIndex = 10

constexpr

Definition at line 34 of file paint.cc.

kMaskFilterIndex

constexpr int flutter::kMaskFilterIndex = 9

constexpr

Definition at line 33 of file paint.cc.

kMaskFilterSigmaIndex

constexpr int flutter::kMaskFilterSigmaIndex = 11

constexpr

Definition at line 35 of file paint.cc.

kMaxCount

constexpr size_t flutter::kMaxCount = 4

staticconstexpr

Definition at line 287 of file dart_vm.cc.

kMaxFrameMarkers [1/2]

const size_t flutter::kMaxFrameMarkers = 8

static

Definition at line 18 of file stopwatch_dl.cc.

kMaxFrameMarkers [2/2]

const size_t flutter::kMaxFrameMarkers = 8

static

Definition at line 16 of file stopwatch_sk.cc.

kMaxSamples [1/3]

const size_t flutter::kMaxSamples = 120

static

Definition at line 9 of file stopwatch.cc.

kMaxSamples [2/3]

const size_t flutter::kMaxSamples = 120

static

Definition at line 17 of file stopwatch_dl.cc.

kMaxSamples [3/3]

const size_t flutter::kMaxSamples = 120

static

Definition at line 15 of file stopwatch_sk.cc.

kMegaByteSizeInBytes

constexpr double flutter::kMegaByteSizeInBytes = (1 << 20)

constexpr

Definition at line 9 of file constants.h.

kMinCount

constexpr size_t flutter::kMinCount = 2

staticconstexpr

Definition at line 286 of file dart_vm.cc.

kMinimumAndroidApiLevelForVulkan

constexpr int flutter::kMinimumAndroidApiLevelForVulkan = 29

constexpr

Definition at line 35 of file flutter_main.cc.

kMinPlatformViewId

constexpr int32_t flutter::kMinPlatformViewId = -1

constexpr

Definition at line 11 of file semantics_node.cc.

kNameKey

const char* flutter::kNameKey = "name"

static

Definition at line 27 of file callback_cache.cc.

kNavigationChannel

constexpr char flutter::kNavigationChannel[] = "flutter/navigation"

staticconstexpr

Definition at line 29 of file engine.cc.

kObjectCount

constexpr int flutter::kObjectCount = 3

constexpr

Definition at line 45 of file paint.cc.

kOpaqueBlack

constexpr int flutter::kOpaqueBlack = 0xff000000

constexpr

Definition at line 12 of file compositor_software.cc.

kOrientationUpdateNotificationKey

const char *const flutter::kOrientationUpdateNotificationKey

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOrientationNotificationKey"

Definition at line 34 of file FlutterPlatformPlugin.mm.

kOrientationUpdateNotificationName

const char *const flutter::kOrientationUpdateNotificationName

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOrientationNotificationName"

Definition at line 32 of file FlutterPlatformPlugin.mm.

kOverlayStyleUpdateNotificationKey

const char *const flutter::kOverlayStyleUpdateNotificationKey

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOverlayNotificationKey"

Definition at line 38 of file FlutterPlatformPlugin.mm.

kOverlayStyleUpdateNotificationName

const char *const flutter::kOverlayStyleUpdateNotificationName

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOverlayNotificationName"

Definition at line 36 of file FlutterPlatformPlugin.mm.

kPlatformStrongDill

const uint8_t flutter::kPlatformStrongDill[]

extern

kPlatformStrongDillSize

const intptr_t flutter::kPlatformStrongDillSize

extern

kPointerDataFieldCount

constexpr int flutter::kPointerDataFieldCount = 36

staticconstexpr

Definition at line 19 of file pointer_data.cc.

kRepresentationKey

const char* flutter::kRepresentationKey = "representation"

static

Definition at line 26 of file callback_cache.cc.

kRootViewIdentifier

const auto flutter::kRootViewIdentifier = EmbedderExternalView::ViewIdentifier{}

static

Definition at line 17 of file embedder_external_view_embedder.cc.

kScanCodeControlLeft

constexpr int flutter::kScanCodeControlLeft = 0x1d

constexpr

Definition at line 19 of file keyboard_utils.h.

kScanCodeControlRight

constexpr int flutter::kScanCodeControlRight = 0xe01d

constexpr

Definition at line 20 of file keyboard_utils.h.

kScanCodeShiftLeft

constexpr int flutter::kScanCodeShiftLeft = 0x2a

constexpr

Definition at line 16 of file keyboard_utils.h.

kScanCodeShiftRight

constexpr int flutter::kScanCodeShiftRight = 0x36

constexpr

Definition at line 17 of file keyboard_utils.h.

kScrollableSemanticsActions

const int flutter::kScrollableSemanticsActions

Initial value:

=
    kVerticalScrollSemanticsActions | kHorizontalScrollSemanticsActions

Definition at line 56 of file semantics_node.h.

kScrollableSemanticsFlags

const int flutter::kScrollableSemanticsFlags

Initial value:

=
    static_cast<int32_t>(SemanticsFlags::kHasImplicitScrolling)

Definition at line 96 of file semantics_node.h.

kSerialGCArgs

const char* flutter::kSerialGCArgs[]

static

Initial value:

= {
    
    "--concurrent_mark=false",
    "--concurrent_sweep=false",
    "--compactor_tasks=1",
    "--scavenger_tasks=0",
    "--marker_tasks=0",
    
}

Definition at line 64 of file dart_vm.cc.

kSettingsChannel

constexpr char flutter::kSettingsChannel[] = "flutter/settings"

staticconstexpr

Definition at line 31 of file engine.cc.

kShaderIndex

constexpr int flutter::kShaderIndex = 0

constexpr

Definition at line 42 of file paint.cc.

kShift

constexpr int flutter::kShift = 1 << 0

constexpr

Definition at line 14 of file keyboard_utils.h.

kSizeFactorSmall

const double flutter::kSizeFactorSmall = 0.3

Definition at line 316 of file dl_region_benchmarks.cc.

kSkiaChannel

constexpr char flutter::kSkiaChannel[] = "flutter/skia"

constexpr

Definition at line 48 of file shell.cc.

kSkMatrixIndexToMatrix4Index

const int flutter::kSkMatrixIndexToMatrix4Index[]

static

Initial value:

= {
    
    0, 4, 12,
    1, 5, 13,
    3, 7, 15,
    
}

Definition at line 13 of file matrix.cc.

kStderrStreamId

const char flutter::kStderrStreamId[] = "Stderr"

static

Definition at line 184 of file dart_vm.cc.

kStdoutStreamId

const char flutter::kStdoutStreamId[] = "Stdout"

static

Definition at line 183 of file dart_vm.cc.

kStrokeCapIndex

constexpr int flutter::kStrokeCapIndex = 5

constexpr

Definition at line 29 of file paint.cc.

kStrokeJoinIndex

constexpr int flutter::kStrokeJoinIndex = 6

constexpr

Definition at line 30 of file paint.cc.

kStrokeMiterLimitDefault

constexpr float flutter::kStrokeMiterLimitDefault = 4.0f

constexpr

Definition at line 56 of file paint.cc.

kStrokeMiterLimitIndex

constexpr int flutter::kStrokeMiterLimitIndex = 7

constexpr

Definition at line 31 of file paint.cc.

kStrokeWidthIndex

constexpr int flutter::kStrokeWidthIndex = 4

constexpr

Definition at line 28 of file paint.cc.

kStyleIndex

constexpr int flutter::kStyleIndex = 3

constexpr

Definition at line 27 of file paint.cc.

kSystemChannel

constexpr char flutter::kSystemChannel[] = "flutter/system"

constexpr

Definition at line 49 of file shell.cc.

kTypeKey

constexpr char flutter::kTypeKey[] = "type"

constexpr

Definition at line 50 of file shell.cc.

kUnicodePlane

const uint64_t flutter::kUnicodePlane = 0x00000000000

The plane value for keys which have a Unicode representation.

Definition at line 23 of file KeyCodeMap.g.mm.

kUnknownDisplayRefreshRate

constexpr double flutter::kUnknownDisplayRefreshRate = 0

staticconstexpr

To be used when the display refresh rate is unknown.

Definition at line 20 of file display.h.

kValueMask

const uint64_t flutter::kValueMask = 0x000ffffffff

Mask for the 32-bit value portion of the key code.

Definition at line 22 of file KeyCodeMap.g.mm.

kVerticalScrollSemanticsActions

const int flutter::kVerticalScrollSemanticsActions

Initial value:

=
    static_cast<int32_t>(SemanticsAction::kScrollUp) |
    static_cast<int32_t>(SemanticsAction::kScrollDown)

Definition at line 48 of file semantics_node.h.

kViewIdPrefx

constexpr std::string_view flutter::kViewIdPrefx = "_flutterView/"

staticconstexpr

Definition at line 46 of file service_protocol.cc.

kVisualizeEngineStatistics

const int flutter::kVisualizeEngineStatistics = 1 << 3

Definition at line 21 of file performance_overlay_layer.h.

kVisualizeRasterizerStatistics

const int flutter::kVisualizeRasterizerStatistics = 1 << 1

Definition at line 19 of file performance_overlay_layer.h.

kVsyncFlowName

constexpr const char* flutter::kVsyncFlowName = "VsyncFlow"

staticconstexpr

Definition at line 17 of file vsync_waiter.cc.

kVsyncTraceName

constexpr const char* flutter::kVsyncTraceName = "VsyncProcessCallback"

staticconstexpr

Definition at line 19 of file vsync_waiter.cc.

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 flutter::manager

Definition at line 218 of file switches.h.

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 flutter::mode

Definition at line 228 of file switches.h.

modifierFlagToKeyCode

const NSDictionary * flutter::modifierFlagToKeyCode

Initial value:

= @{
  @(kModifierFlagShiftLeft) : @0x00000038,
  @(kModifierFlagShiftRight) : @0x0000003c,
  @(kModifierFlagControlLeft) : @0x0000003b,
  @(kModifierFlagControlRight) : @0x0000003e,
  @(kModifierFlagAltLeft) : @0x0000003a,
  @(kModifierFlagAltRight) : @0x0000003d,
  @(kModifierFlagMetaLeft) : @0x00000037,
  @(kModifierFlagMetaRight) : @0x00000036,
}

Map a bit of bitmask of NSEventModifierFlags to its corresponding |NSEvent.keyCode|.

This does not include CapsLock, for it is handled specially.

Definition at line 234 of file KeyCodeMap.g.mm.

name

DEF_SWITCHES_START aot vmservice shared library flutter::name

Definition at line 32 of file switches.h.

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 which is used for Skia shader cache icu native lib flutter::path

Definition at line 57 of file switches.h.

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 flutter::policy

Definition at line 248 of file switches.h.

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 flutter::port

Definition at line 87 of file switches.h.

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 flutter::publication

Definition at line 110 of file switches.h.

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 flutter::route

Definition at line 137 of file switches.h.

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 flutter::service

Definition at line 99 of file switches.h.

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 flutter::set

Definition at line 76 of file switches.h.

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 flutter::size

Definition at line 259 of file switches.h.

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 flutter::startup

Definition at line 162 of file switches.h.

tracing

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 enable vulkan gpu flutter::tracing

Definition at line 283 of file switches.h.

validation

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 flutter::validation

Definition at line 274 of file switches.h.