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
struct	ActualWindowSize
class	AlertPlatformNodeDelegate
class	AndroidContext
	Holds state that is shared across Android surfaces. More...
class	AndroidContextDynamicImpeller
	An Impeller Android context that dynamically creates either an [AndroidContextGLImpeller] or an [AndroidContextVKImpeller]. More...
class	AndroidContextGLImpeller
class	AndroidContextGLSkia
class	AndroidContextVKImpeller
class	AndroidDisplay
	A |Display| that listens to refresh rate changes. More...
class	AndroidEGLSurface
class	AndroidEGLSurfaceDamage
class	AndroidEnvironmentGL
class	AndroidExternalViewEmbedder
class	AndroidExternalViewEmbedder2
class	AndroidExternalViewEmbedderWrapper
class	AndroidImageGenerator
class	AndroidNativeWindow
class	AndroidShellHolder
	This is the Android owner of the core engine Shell. More...
class	AndroidSnapshotSurfaceProducer
class	AndroidSurface
class	AndroidSurfaceDynamicImpeller
	An Impeller Android surface class that dynamically creates either an [AndroidSurfaceVKImpeller] or an [AndroidSurfaceGLImpeller]. More...
class	AndroidSurfaceFactory
class	AndroidSurfaceFactoryImpl
class	AndroidSurfaceGLImpeller
class	AndroidSurfaceGLSkia
class	AndroidSurfaceMock
class	AndroidSurfaceSoftware
class	AndroidSurfaceVKImpeller
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	BoxConstraints
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	ClipRSuperellipseEntry
class	ClipRSuperellipseLayer
class	ClipShapeLayer
class	Codec
class	ColorFilter
class	ColorFilterEntry
class	ColorFilterLayer
class	ComplexityCalculatorHelper
class	Compositor
class	CompositorContext
class	CompositorOpenGL
class	CompositorSoftware
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	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
struct	DialogWindowCreationRequest
class	DidDrawCanvas
class	DiffContext
class	DirectManipulationEventHandler
class	DirectManipulationOwner
class	DirectoryAssetBundle
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	DisplayManagerWin32
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	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	DlOpReceiverIgnore
class	DlOpSpy
class	DlPaint
class	DlPath
class	DlPathBuilder
class	DlRadialGradientColorSource
class	DlRegion
class	DlRTree
class	DlRuntimeEffect
class	DlRuntimeEffectColorSource
class	DlRuntimeEffectImageFilter
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	DlText
class	DlTextImpeller
class	DlTextSkia
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	DrawTextOp
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	EmbedderSurfaceVulkanImpeller
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	FlutterMain
class	FlutterPlatformNodeDelegate
class	FlutterPlatformNodeDelegateMac
class	FlutterPlatformNodeDelegateWindows
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
struct	FullscreenRequest
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	GPUSurfaceNoop
	A rendering surface that accepts rendering intent but does not render anything. More...
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	HostWindow
class	HostWindowDialog
class	HostWindowRegular
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
	External texture peered to a sequence of android.hardware.HardwareBuffers. More...
class	ImageExternalTextureGL
class	ImageExternalTextureGLImpeller
class	ImageExternalTextureGLSkia
class	ImageExternalTextureVKImpeller
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	IOSContextNoop
	A noop rendering context for usage on simulators without metal support. More...
class	IOSExternalTextureMetal
class	IOSExternalViewEmbedder
class	IOSSurface
class	IOSSurfaceMetalImpeller
class	IOSSurfaceNoop
	A rendering surface that accepts rendering intent but does not render anything. More...
class	Isolate
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	IsolateScope
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	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	NativeAssetsManager
class	NativeSemanticsFlags
	The peer class for all of the SemanticsFlags subclasses in semantics.dart. More...
class	NativeStringAttribute
	The peer class for all of the StringAttribute subclasses in semantics.dart. More...
class	OffscreenSurface
class	OpacityEntry
class	OpacityLayer
struct	OverlayLayer
	State holder for a Flutter overlay layer. More...
class	OverlayLayerPool
	Storage for Overlay layers across frames. More...
class	Paint
struct	PaintContext
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
struct	RegularWindowCreationRequest
class	ResourceCacheLimitCalculator
class	ResourceCacheLimitItem
struct	RestoreOp
class	ReusableFragmentShader
struct	RotateOp
class	RRect
class	RSuperellipse
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	SaveInfo
struct	SaveLayerBackdropOp
class	SaveLayerEntry
struct	SaveLayerOp
struct	SaveLayerOpBase
class	SaveLayerOptions
struct	SaveOp
struct	SaveOpBase
struct	ScaleOp
class	Scene
class	SceneBuilder
class	ScopedClipboardInterface
class	ScriptCompletionTaskObserver
struct	SemanticsFlags
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	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
	Instances of external textures peered to android.graphics.SurfaceTexture. More...
class	SurfaceTextureExternalTextureGLImpeller
	Binds the surface texture to an Impeller texture. More...
class	SurfaceTextureExternalTextureGLSkia
	Binds the surface texture to a Skia SkImage. More...
class	SurfaceTextureExternalTextureVKImpeller
	An external texture implementation for Vulkan that uses OpenGL to Vulkan texture interop to read SurfaceTexture based image data and render it into a Vulkan texture. More...
class	SwitchableGLContext
class	TaskRunner
class	TaskRunners
class	TaskRunnerWindow
class	TestAccessibilityBridge
class	TestBinaryMessenger
class	TestCustomValue
class	TesterExternalViewEmbedder
class	TesterGPUSurfaceSoftware
class	TesterPlatformView
struct	TextEditingDelta
	A change in the state of an input field. More...
class	TextInputManager
class	TextInputModel
class	TextInputPlugin
class	TextInputPluginModifier
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	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	Vertices
class	ViewFocusChangeRequest
class	ViewFocusEvent
class	ViewModifier
struct	ViewportMetrics
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	WindowConstraints
struct	WindowFrame
struct	WindowingInitRequest
class	WindowManager
class	WindowProcDelegateManager
struct	WindowProperties
struct	WindowSizeRequest
class	WindowsLifecycleManager
struct	WindowsMessage
class	WindowsProcTable
class	WrappedTextureSourceVK

Typedefs
using	TaskObserverAdd = std::function< fml::TaskQueueId(intptr_t, fml::closure)>
using	TaskObserverRemove = std::function< void(fml::TaskQueueId, 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	DlIndex = uint32_t
using	DlBlendMode = impeller::BlendMode
using	Flags = DlVertices::Builder::Flags
using	DlScalar = impeller::Scalar
using	DlDegrees = impeller::Degrees
using	DlRadians = impeller::Radians
using	DlPoint = impeller::Point
using	DlVector2 = impeller::Vector2
using	DlVector3 = impeller::Vector3
using	DlIPoint = impeller::IPoint32
using	DlSize = impeller::Size
using	DlISize = impeller::ISize32
using	DlRect = impeller::Rect
using	DlIRect = impeller::IRect32
using	DlRoundRect = impeller::RoundRect
using	DlRoundSuperellipse = impeller::RoundSuperellipse
using	DlRoundingRadii = impeller::RoundingRadii
using	DlMatrix = impeller::Matrix
using	DlQuad = impeller::Quad
using	DlRSTransform = impeller::RSTransform
using	FillType = impeller::FillType
using	Convexity = impeller::Convexity
using	DlPathFillType = impeller::FillType
using	DlPathReceiver = impeller::PathReceiver
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.
using	CustomAccessibilityActionUpdates = std::unordered_map< int32_t, CustomAccessibilityAction >
using	SemanticsNodeUpdates = std::unordered_map< int32_t, SemanticsNode >
using	StringAttributePtr = std::shared_ptr< flutter::StringAttribute >
using	StringAttributes = std::vector< StringAttributePtr >
using	ChildIsolatePreparer = std::function< bool(DartIsolate *)>
typedef size_t	DisplayId
using	PointerDataDispatcherMaker = std::function< std::unique_ptr< PointerDataDispatcher >(PointerDataDispatcher::Delegate &)>
	Signature for constructing PointerDataDispatcher.
using	FramePipeline = Pipeline< FrameItem >
using	ThreadConfig = fml::Thread::ThreadConfig
using	ThreadConfigSetter = fml::Thread::ThreadConfigSetter
typedef void *	GPUMTLDeviceHandle
typedef void *	GPUMTLCommandQueueHandle
typedef void *	GPUCAMetalLayerHandle
typedef const void *	GPUMTLTextureHandle
typedef void(*	GPUMTLDestructionCallback) (void *)
template<class T >
using	EGLResult = std::pair< bool, T >
using	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 >
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.

Enumerations
enum class	DisplayListOpType {   kInvalidOp ,   kMaxOp = kInvalidOp }
enum class	DisplayListOpCategory {   kAttribute ,   kTransform ,   kClip ,   kSave ,   kSaveLayer ,   kRestore ,   kRendering ,   kSubDisplayList ,   kInvalidCategory ,   kMaxCategory = kInvalidCategory }
enum class	DlColorSpace {   kSRGB = 0 ,   kExtendedSRGB = 1 ,   kDisplayP3 = 2 }
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	DlClipOp {   kDifference ,   kIntersect }
enum class	DlPointMode {   kPoints ,   kLines ,   kPolygon }
enum class	DlSrcRectConstraint {   kStrict ,   kFast }
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 {   kImage ,   kLinearGradient ,   kRadialGradient ,   kConicalGradient ,   kSweepGradient ,   kRuntimeEffect }
enum class	DlImageFilterType {   kBlur ,   kDilate ,   kErode ,   kMatrix ,   kRuntimeEffect ,   kColorFilter ,   kCompose ,   kLocalMatrix }
enum class	DlMaskFilterType { kBlur }
enum class	DlBlurStyle {   kNormal ,   kSolid ,   kOuter ,   kInner }
enum class	RasterStatus {   kSuccess ,   kResubmit ,   kSkipAndRetry }
enum class	MutatorType {   kClipRect ,   kClipRRect ,   kClipRSE ,   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	SemanticsTristate : int32_t {   kNone = 0 ,   kTrue = 1 ,   kFalse = 2 }
enum class	SemanticsCheckState : int32_t {   kNone = 0 ,   kTrue = 1 ,   kFalse = 2 ,   kMixed = 3 }
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 ,   kScrollToOffset = 1 << 23 ,   kExpand = 1 << 24 ,   kCollapse = 1 << 25 }
enum class	SemanticsRole : int32_t {   kNone = 0 ,   kTab = 1 ,   kTabBar = 2 ,   kTabPanel = 3 ,   kDialog = 4 ,   kAlertDialog = 5 ,   kTable = 6 ,   kCell = 7 ,   kRow = 8 ,   kColumnHeader = 9 ,   kDragHandle = 10 ,   kSpinButton = 11 ,   kComboBox = 12 ,   kMenuBar = 13 ,   kMenu = 14 ,   kMenuItem = 15 ,   kMenuItemCheckbox = 16 ,   kMenuItemRadio = 17 ,   kList = 18 ,   kListItem = 19 ,   kForm = 20 ,   kTooltip = 21 ,   kLoadingSpinner = 22 ,   kProgressBar = 23 ,   kHotKey = 24 ,   kRadioGroup = 25 ,   kStatus = 26 ,   kAlert = 27 ,   kComplementary = 28 ,   kContentInfo = 29 ,   kMain = 30 ,   kNavigation = 31 ,   kRegion = 32 }
enum class	SemanticsValidationResult : int32_t {   kNone = 0 ,   kValid = 1 ,   kInvalid = 2 }
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 ,   kNoAnnounce = 1 << 7 }
	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	ViewFocusState : int64_t {   kUnfocused = 0 ,   kFocused }
enum class	ViewFocusDirection : int64_t {   kUndefined = 0 ,   kForward ,   kBackward }
enum class	IsolateLaunchType {   kNewGroup ,   kExistingGroup }
enum class	TracingResult {   kNotAttempted ,   kEnabled ,   kNotNecessary = kEnabled ,   kDisabled }
enum class	ContextType {   kRender ,   kResource }
enum class	PipelineConsumeResult {   NoneAvailable ,   Done ,   MoreAvailable }
enum class	DrawStatus {   kDone ,   kNotSetUp ,   kYielded ,   kPipelineEmpty ,   kGpuUnavailable }
enum class	DrawSurfaceStatus {   kSuccess ,   kRetry ,   kFailed ,   kDiscarded }
enum class	DartErrorCode {   NoError = 0 ,   ApiError = 253 ,   CompilationError = 254 ,   UnknownError = 255 }
	Error exit codes for the Dart isolate. More...
enum class	GpuAvailability {   kAvailable = 0 ,   kFlushAndMakeUnavailable = 1 ,   kUnavailable = 2 }
	Values for |Shell::SetGpuAvailability|. More...
enum class	MTLRenderTargetType {   kMTLTexture ,   kCAMetalLayer }
enum class	AndroidEGLSurfaceMakeCurrentStatus {   kSuccessAlreadyCurrent ,   kSuccessMadeCurrent ,   kFailure }
	Result of calling MakeCurrent on AndroidEGLSurface. More...
enum class	AndroidRenderingAPI {   kSoftware ,   kSkiaOpenGLES ,   kImpellerOpenGLES ,   kImpellerVulkan ,   kImpellerAutoselect }
enum class	LayoutUpdateMode {   kSync ,   kAsync }
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	WindowArchetype {   kRegular ,   kDialog }
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	GpuPreference {   NoPreference ,   LowPowerPreference }
enum class	UIThreadPolicy {   Default ,   RunOnPlatformThread ,   RunOnSeparateThread }
enum class	FlutterGpuPreference {   NoPreference ,   LowPowerPreference }
enum class	FlutterUIThreadPolicy {   Default ,   RunOnPlatformThread ,   RunOnSeparateThread }
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)
static void	BM_DisplayListDispatchDefault (benchmark::State &state, DisplayListDispatchBenchmarkType type)
static void	BM_DisplayListDispatchByIndexDefault (benchmark::State &state, DisplayListDispatchBenchmarkType type)
static void	BM_DisplayListDispatchByIteratorDefault (benchmark::State &state, DisplayListDispatchBenchmarkType type)
static void	BM_DisplayListDispatchByVectorDefault (benchmark::State &state, DisplayListDispatchBenchmarkType type)
static void	BM_DisplayListDispatchCull (benchmark::State &state, DisplayListDispatchBenchmarkType type)
static void	BM_DisplayListDispatchByVectorCull (benchmark::State &state, DisplayListDispatchBenchmarkType 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)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchDefault, kDefaultNoRtree, DisplayListDispatchBenchmarkType::kDefaultNoRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchDefault, kDefaultWithRtree, DisplayListDispatchBenchmarkType::kDefaultWithRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchCull, kCulledWithRtree, DisplayListDispatchBenchmarkType::kCulledWithRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchByIndexDefault, kDefaultNoRtree, DisplayListDispatchBenchmarkType::kDefaultNoRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchByIteratorDefault, kDefaultNoRtree, DisplayListDispatchBenchmarkType::kDefaultNoRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchByVectorDefault, kDefaultNoRtree, DisplayListDispatchBenchmarkType::kDefaultNoRtree) -> Unit(benchmark::kMicrosecond)
	BENCHMARK_CAPTURE (BM_DisplayListDispatchByVectorCull, kCulledWithRtree, DisplayListDispatchBenchmarkType::kCulledWithRtree) -> 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 void	FillAllIndices (std::vector< DlIndex > &indices, DlIndex size)
static bool	CompareOps (const DisplayListStorage &storageA, const std::vector< size_t > &offsetsA, const DisplayListStorage &storageB, const std::vector< size_t > &offsetsB)
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 const DlRect &	ProtectEmpty (const DlRect &rect)
	DEFINE_DRAW_POINTS_OP (Points, kPoints)
	DEFINE_DRAW_POINTS_OP (Lines, kLines)
	DEFINE_DRAW_POINTS_OP (Polygon, kPolygon)
static constexpr bool	is_power_of_two (int value)
static void	DlVerticesDeleter (void *p)
static size_t	bytes_needed (int vertex_count, Flags flags, int index_count)
static DlRect	compute_bounds (const DlPoint *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 DlRect	ToDlRect (const SkIRect &rect)
const DlIRect &	ToDlIRect (const SkIRect &rect)
const DlISize &	ToDlISize (const SkISize &size)
const DlSize &	ToDlSize (const SkVector &vector)
const DlRoundRect	ToDlRoundRect (const SkRRect &rrect)
DlMatrix	ToDlMatrix (const SkMatrix &matrix)
DlMatrix	ToDlMatrix (const SkM44 &matrix)
const SkPoint &	ToSkPoint (const DlPoint &point)
const SkPoint *	ToSkPoints (const DlPoint *points)
SkPoint *	ToSkPoints (DlPoint *points)
const SkRect &	ToSkRect (const DlRect &rect)
const SkIRect &	ToSkIRect (const DlIRect &rect)
std::optional< const SkIRect >	ToOptSkIRect (std::optional< const DlIRect > rect)
const SkRect *	ToSkRect (const DlRect *rect)
const SkRect *	ToSkRect (const std::optional< DlRect > &rect)
SkRect *	ToSkRect (DlRect *rect)
const SkRect *	ToSkRects (const DlRect *rects)
const SkIRect *	ToSkIRects (const DlIRect *rects)
const SkSize &	ToSkSize (const DlSize &size)
const SkISize &	ToSkISize (const DlISize &size)
const SkVector &	ToSkVector (const DlSize &size)
const SkRRect	ToSkRRect (const DlRoundRect &round_rect)
const SkRRect	ToApproximateSkRRect (const DlRoundSuperellipse &rse)
SkMatrix	ToSkMatrix (const DlMatrix &matrix)
SkM44	ToSkM44 (const DlMatrix &matrix)
constexpr bool	DlScalarNearlyZero (DlScalar x, DlScalar tolerance=kEhCloseEnough)
constexpr bool	DlScalarNearlyEqual (DlScalar x, DlScalar y, DlScalar tolerance=kEhCloseEnough)
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 std::shared_ptr< DlVertices > &vertices)
SkBlendMode	ToSk (DlBlendMode mode)
SkColor4f	ToSkColor4f (DlColor color)
SkColor	ToSkColor (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 (DlSrcRectConstraint constraint)
SkClipOp	ToSk (DlClipOp op)
SkCanvas::PointMode	ToSk (DlPointMode 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< 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)
SkMatrix *	ToSk (const DlMatrix *matrix, SkMatrix &scratch)
const SkRSXform *	ToSk (const DlRSTransform *transforms)
template<class T , class U >
bool	Equals (const T *a, const U *b)
template<class T , class U >
bool	Equals (const std::shared_ptr< const T > &a, const U *b)
template<class T , class U >
bool	Equals (const std::shared_ptr< T > &a, const U *b)
template<class T , class U >
bool	Equals (const T *a, const std::shared_ptr< const U > &b)
template<class T , class U >
bool	Equals (const T *a, const std::shared_ptr< U > &b)
template<class T , class U >
bool	Equals (const std::shared_ptr< const T > &a, const std::shared_ptr< const U > &b)
template<class T , class U >
bool	Equals (const std::shared_ptr< T > &a, const std::shared_ptr< const U > &b)
template<class T , class U >
bool	Equals (const std::shared_ptr< const T > &a, const std::shared_ptr< U > &b)
template<class T , class U >
bool	Equals (const std::shared_ptr< T > &a, const std::shared_ptr< U > &b)
template<class T , class U >
bool	NotEquals (const T *a, const U *b)
template<class T , class U >
bool	NotEquals (const std::shared_ptr< const T > &a, const U *b)
template<class T , class U >
bool	NotEquals (const std::shared_ptr< T > &a, const U *b)
template<class T , class U >
bool	NotEquals (const T *a, const std::shared_ptr< const U > &b)
template<class T , class U >
bool	NotEquals (const T *a, const std::shared_ptr< U > &b)
template<class T , class U >
bool	NotEquals (const std::shared_ptr< const T > &a, const std::shared_ptr< const U > &b)
template<class T , class U >
bool	NotEquals (const std::shared_ptr< T > &a, const std::shared_ptr< const U > &b)
template<class T , class U >
bool	NotEquals (const std::shared_ptr< const T > &a, const std::shared_ptr< U > &b)
template<class T , class U >
bool	NotEquals (const std::shared_ptr< T > &a, const std::shared_ptr< U > &b)
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	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 DlISize &size)
static sk_sp< SkData >	GetRasterData (const sk_sp< SkSurface > &offscreen_surface, bool compressed)
void	DrawCheckerboard (DlCanvas *canvas, const DlRect &rect)
	TEST (FlowTest, SurfaceFrameDoesNotSubmitInDtor)
	TEST (FlowTest, SurfaceFrameDoesNotHaveEmptyCanvas)
	TEST (FlowTest, SurfaceFrameDoesNotPrepareRtree)
std::unordered_map< int64_t, DlRect >	SliceViews (DlCanvas *background_canvas, const std::vector< int64_t > &composition_order, const std::unordered_map< int64_t, std::unique_ptr< EmbedderViewSlice > > &slices, const std::unordered_map< int64_t, DlRect > &view_rects)
	Compute the required overlay layers and clip the view slices according to the size and position of the platform views.
	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, const 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, bool enable_microtask_profiling)
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 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)
DlMatrix	ToDlMatrix (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, const fml::RefPtr< SkiaUnrefQueue > &unref_queue)
	IMPLEMENT_WRAPPERTYPEINFO (ui, PictureRecorder)
	IMPLEMENT_WRAPPERTYPEINFO (ui, RSuperellipse)
	IMPLEMENT_WRAPPERTYPEINFO (ui, Shader)
	IMPLEMENT_WRAPPERTYPEINFO (ui, Vertices)
	IMPLEMENT_WRAPPERTYPEINFO (ui, NativeSemanticsFlags)
	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)
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 *	NativeAssetsDlopen (const char *asset_id, char **error)
static char *	NativeAssetsAvailableAssets ()
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_paths, 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 ()
static bool	ServiceStreamListenCallback (const char *stream_id)
static void	ServiceStreamCancelCallback (const char *stream_id)
static std::vector< const char * >	ProfilingFlags (bool enable_profiling, bool profile_startup)
void	PushBackAll (std::vector< const char * > *args, const char **argv, size_t argc)
static void	EmbedderInformationCallback (Dart_EmbedderInformation *info)
static std::vector< std::string >	ParseKernelListPaths (std::unique_ptr< fml::Mapping > kernel_list)
static std::vector< std::future< std::unique_ptr< const fml::Mapping > > >	PrepareKernelMappings (const std::vector< std::string > &kernel_pieces_paths, const std::shared_ptr< AssetManager > &asset_manager, const fml::RefPtr< fml::TaskRunner > &io_worker)
bool	EnableTracingIfNecessary (const Settings &vm_settings)
	Enables tracing in the process so that JIT mode VMs may be launched. Explicitly enabling tracing is not required on all platforms. On platforms where it is not required, calling this method will return true. If tracing is required but cannot be enabled, it is the responsibility of the caller to display the appropriate error message to the user as subsequent attempts to launch the VM in JIT mode will cause process termination.
TracingResult	GetTracingResult ()
	Returns if a tracing check has been performed and its result. To enable tracing, the Settings object used to launch the VM is required. Components may want to display messages based on the result of a previous tracing check without actually having the settings object. This accessor can be used instead.
static void	WriteServerErrorResponse (rapidjson::Document *document, const char *message)
static bool	HandleMessageOnHandler (ServiceProtocol::Handler *handler, std::string_view method, const ServiceProtocol::Handler::ServiceProtocolMap &params, rapidjson::Document *document)
static std::string	CreateFlutterViewID (intptr_t handler)
static std::string	CreateIsolateID (int64_t isolate)
std::vector< sk_sp< SkTypeface > >	GetTestFontData ()
std::vector< std::string >	GetTestFontFamilyNames ()
GrContextOptions	MakeDefaultContextOptions (ContextType type, std::optional< GrBackendApi > api=std::nullopt)
	Initializes GrContextOptions with values suitable for Flutter. The options can be further tweaked before a GrContext is created from these options.
	TEST_F (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)
	TEST (RasterizerTest, isAiksContextInitialized)
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 void	ServiceProtocolParameterError (rapidjson::Document *response, std::string error_details)
static void	ServiceProtocolFailureError (rapidjson::Document *response, std::string message)
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)
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 (DeviceVMServicePort, "vm-service-port", "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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode	DEF_SWITCH (DisableVMServicePublication, "disable-vm-service-publication", "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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode 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(ProfileStartup
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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring meaning that once it is new samples start overwriting the oldest ones This switch is only meaningful when set in conjunction with enable dart profiling	DEF_SWITCH (EndlessTraceBuffer, "endless-trace-buffer", "Enable an endless trace buffer. The default is a ring buffer. " "This is useful when very old events need to viewed. For example, " "during application launch. Memory usage will continue to grow " "indefinitely however.") DEF_SWITCH(EnableSoftwareRendering
it will be possible to load the file into Perfetto s trace viewer	DEF_SWITCH (ProfileMicrotasks, "profile-microtasks", "Enable collection of information about each microtask. Information " "about completed microtasks will be written to the \"Microtask\" " "timeline stream. Information about queued microtasks will be " "accessible from Dart / Flutter DevTools.") DEF_SWITCH(UseTestFonts
it will be possible to load the file into Perfetto s trace viewer use test 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:"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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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
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, bool require_merged_platform_ui_thread)
	TEST (Point, SetsCoordinates)
	TEST (Size, SetsDimensions)
	TEST (Size, ClampsDimensionsPositive)
	TEST (Rect, SetsOriginAndSize)
	TEST (Rect, ReturnsLTRB)
	TEST (Rect, ReturnsWidthHeight)
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 DlISize &size, intptr_t fbo)
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, const AndroidContext::ContextSettings &p_settings)
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 (const flutter::TaskRunners &task_runners, AndroidRenderingAPI android_rendering_api, bool enable_opengl_gpu_tracing, const AndroidContext::ContextSettings &settings)
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, jlong engineId)
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, jlong engineId)
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 bool	IsSurfaceControlEnabled (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, jboolean reset_on_background)
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)
static bool	SetTextureLayout (const ContextVK &context, const TextureSourceVK *texture, vk::ImageLayout layout, LayoutUpdateMode mode)
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 (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)
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 DlISize	TransformedSurfaceSize (const DlISize &size, const DlMatrix &transformation)
static void	InvalidateApiState (SkSurface &skia_surface)
static FlutterBackingStoreConfig	MakeBackingStoreConfig (int64_t view_id, const DlISize &backing_store_size)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (double opacity)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (const DlRect &rect)
static FlutterSize	ConvertSize (const DlSize &vector)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (const DlRoundRect &rrect)
static std::unique_ptr< FlutterPlatformViewMutation >	ConvertMutation (const DlMatrix &matrix)
FlutterSemanticsFlag	SemanticsFlagsToInt (const SemanticsFlags &flags)
static std::pair< bool, fml::RefPtr< EmbedderTaskRunner > >	CreateEmbedderTaskRunner (const FlutterTaskRunnerDescription *description)
	Attempts to create a task runner from an embedder task runner description. The first boolean in the pair indicate whether the embedder specified an invalid task runner description. In this case, engine launch must be aborted. If the embedder did not specify any task runner, an engine managed task runner and thread must be selected instead.
static fml::RefPtr< fml::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)
LONG	RectWidth (const RECT &r)
LONG	RectHeight (const RECT &r)
bool	AreRectsEqual (const RECT &a, const RECT &b)
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)
std::string	WCharBufferToString (const wchar_t *wstr)
	Convert a null terminated wchar_t buffer to a std::string using Windows utilities.
static int64_t	NumWindowsForThread (const THREADENTRY32 &thread)
static void	ConfigureShell (Shell *shell)
static void	UnblockSIGPROF ()
int	RunTester (const flutter::Settings &settings, bool run_forever, bool multithreaded)
EXPORTED Dart_Handle	LoadLibraryFromKernel (const char *path)
EXPORTED Dart_Handle	LookupEntryPoint (const char *uri, const char *name)
EXPORTED void	Spawn (const char *entrypoint, const char *route)
EXPORTED void	ForceShutdownIsolate ()
const char *	GetFlutterEngineVersion ()
const char *	GetFlutterContentHash ()
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()
static constexpr DlScalar	kEhCloseEnough = impeller::kEhCloseEnough
static constexpr DlScalar	kPi = impeller::kPi
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.
static std::string	gGoldenDir
static std::string	gFontFile
static const auto *	flow_type = "RasterCacheFlow::DisplayList"
static constexpr DlRect	kGiantRect = DlRect::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	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	kColorRedIndex = 1
constexpr int	kColorGreenIndex = 2
constexpr int	kColorBlueIndex = 3
constexpr int	kColorAlphaIndex = 4
constexpr int	kColorSpaceIndex = 5
constexpr int	kBlendModeIndex = 6
constexpr int	kStyleIndex = 7
constexpr int	kStrokeWidthIndex = 8
constexpr int	kStrokeCapIndex = 9
constexpr int	kStrokeJoinIndex = 10
constexpr int	kStrokeMiterLimitIndex = 11
constexpr int	kFilterQualityIndex = 12
constexpr int	kMaskFilterIndex = 13
constexpr int	kMaskFilterBlurStyleIndex = 14
constexpr int	kMaskFilterSigmaIndex = 15
constexpr int	kInvertColorIndex = 16
constexpr size_t	kDataByteCount = 68
constexpr int	kShaderIndex = 0
constexpr int	kColorFilterIndex = 1
constexpr int	kImageFilterIndex = 2
constexpr int	kObjectCount = 3
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
constexpr int	kVerticalScrollSemanticsActions
constexpr int	kHorizontalScrollSemanticsActions
constexpr int	kScrollableSemanticsActions
constexpr int	kSystemActions
	The following actions are not user-initiated.
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 const char *	kDartWriteProtectCodeArgs []
static const char *	kDartDisableIntegerDivisionArgs []
static const char *	kDartAssertArgs []
static const char *	kDartStartPausedArgs []
static const char *	kDartEndlessTraceBufferArgs []
static const char *	kDartSystraceTraceBufferArgs []
static const char *	kDartDefaultTraceStreamsArgs []
static const char *	kDartStartupTraceStreamsArgs []
static const char *	kDartSystraceTraceStreamsArgs []
static const char *	kDartProfileMicrotasksArgs []
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.
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 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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode	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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile	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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring	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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring meaning that once it is	full
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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring meaning that once it is new samples start overwriting the oldest ones This switch is only meaningful when set in conjunction with enable dart profiling enable software	rendering
it will be possible to load the file into Perfetto s trace viewer use test	fonts
it will be possible to load the file into Perfetto s trace viewer use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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 use test 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 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	kMinimumAndroidApiLevelForImpeller = 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_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_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 jmethodID	g_mutators_stack_push_opacity_method = nullptr
static jmethodID	g_mutators_stack_push_clippath_method = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	path_class = nullptr
static jmethodID	path_constructor = nullptr
static jmethodID	path_move_to_method = nullptr
static jmethodID	path_line_to_method = nullptr
static jmethodID	path_quad_to_method = nullptr
static jmethodID	path_cubic_to_method = nullptr
static jmethodID	path_conic_to_method = nullptr
static jmethodID	path_close_method = nullptr
static jmethodID	path_set_fill_type_method = nullptr
static fml::jni::ScopedJavaGlobalRef< jclass > *	g_path_fill_type_class = nullptr
static jfieldID	g_path_fill_type_winding_field = nullptr
static jfieldID	g_path_fill_type_even_odd_field = 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
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 UINT	kDefaultDpi = 96
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 const uintptr_t	kPollTimeoutTimerId = 1
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 24 of file dart_isolate_group_data.h.

Convexity

using flutter::Convexity = typedef impeller::Convexity

Definition at line 37 of file dl_path.cc.

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.

DlBlendMode

using flutter::DlBlendMode = typedef impeller::BlendMode

Definition at line 12 of file dl_blend_mode.h.

DlDegrees

using flutter::DlDegrees = typedef impeller::Degrees

Definition at line 18 of file dl_geometry_types.h.

DlIndex

using flutter::DlIndex = typedef uint32_t

Definition at line 261 of file display_list.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 32 of file dl_geometry_types.h.

DlPathFillType

using flutter::DlPathFillType = typedef impeller::FillType

Definition at line 16 of file dl_path.h.

DlPathReceiver

using flutter::DlPathReceiver = typedef impeller::PathReceiver

Definition at line 17 of file dl_path.h.

DlPoint

using flutter::DlPoint = typedef impeller::Point

Definition at line 21 of file dl_geometry_types.h.

DlQuad

using flutter::DlQuad = typedef impeller::Quad

Definition at line 33 of file dl_geometry_types.h.

DlRadians

using flutter::DlRadians = typedef impeller::Radians

Definition at line 19 of file dl_geometry_types.h.

DlRect

using flutter::DlRect = typedef impeller::Rect

Definition at line 27 of file dl_geometry_types.h.

DlRoundingRadii

using flutter::DlRoundingRadii = typedef impeller::RoundingRadii

Definition at line 31 of file dl_geometry_types.h.

DlRoundRect

using flutter::DlRoundRect = typedef impeller::RoundRect

Definition at line 29 of file dl_geometry_types.h.

DlRoundSuperellipse

using flutter::DlRoundSuperellipse = typedef impeller::RoundSuperellipse

Definition at line 30 of file dl_geometry_types.h.

DlRSTransform

using flutter::DlRSTransform = typedef impeller::RSTransform

Definition at line 34 of file dl_geometry_types.h.

DlScalar

using flutter::DlScalar = typedef impeller::Scalar

Definition at line 17 of file dl_geometry_types.h.

DlSize

using flutter::DlSize = typedef impeller::Size

Definition at line 25 of file dl_geometry_types.h.

DlVector2

using flutter::DlVector2 = typedef impeller::Vector2

Definition at line 22 of file dl_geometry_types.h.

DlVector3

using flutter::DlVector3 = typedef impeller::Vector3

Definition at line 23 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.

FillType

using flutter::FillType = typedef impeller::FillType

Definition at line 36 of file dl_path.cc.

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 15 of file accessibility_plugin.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 91 of file settings.h.

GPUCAMetalLayerHandle

typedef void* flutter::GPUCAMetalLayerHandle

Definition at line 23 of file gpu_surface_metal_delegate.h.

GPUMTLCommandQueueHandle

typedef void* flutter::GPUMTLCommandQueueHandle

Definition at line 20 of file gpu_surface_metal_delegate.h.

GPUMTLDestructionCallback

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

Definition at line 28 of file gpu_surface_metal_delegate.h.

GPUMTLDeviceHandle

typedef void* flutter::GPUMTLDeviceHandle

Definition at line 17 of file gpu_surface_metal_delegate.h.

GPUMTLTextureHandle

typedef const void* flutter::GPUMTLTextureHandle

Definition at line 26 of file gpu_surface_metal_delegate.h.

Gradient

typedef CanvasGradient flutter::Gradient

Definition at line 53 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 51 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.

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 81 of file settings.h.

MappingCallback

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

Definition at line 87 of file settings.h.

Mappings

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

Definition at line 88 of file settings.h.

MappingsCallback

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

Definition at line 89 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 534 of file layer_state_stack.cc.

PaintRegionMap

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

Definition at line 38 of file diff_context.h.

Path

typedef CanvasPath flutter::Path

Definition at line 54 of file dart_ui.cc.

PathMeasure

typedef CanvasPathMeasure flutter::PathMeasure

Definition at line 52 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 172 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 181 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<fml::TaskQueueId(intptr_t , fml::closure )>

Definition at line 73 of file settings.h.

TaskObserverRemove

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

Definition at line 76 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 78 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
kNoAnnounce

Definition at line 43 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,
  kNoAnnounce = 1 << 7,
};

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
kSkiaOpenGLES
kImpellerOpenGLES
kImpellerVulkan
kImpellerAutoselect

Definition at line 11 of file android_rendering_selector.h.

                               {
#if !SLIMPELLER
  kSoftware,
  kSkiaOpenGLES,
#endif  // !SLIMPELLER
  kImpellerOpenGLES,
  kImpellerVulkan,
  kImpellerAutoselect,
};

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 43 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 50 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 31 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,
};

DisplayListOpCategory

enum class flutter::DisplayListOpCategory

strong

Enumerator
kAttribute
kTransform
kClip
kSave
kSaveLayer
kRestore
kRendering
kSubDisplayList
kInvalidCategory
kMaxCategory

Definition at line 151 of file display_list.h.

                                 {
  kAttribute,
  kTransform,
  kClip,
  kSave,
  kSaveLayer,
  kRestore,
  kRendering,
  kSubDisplayList,
  kInvalidCategory,
  kMaxCategory = kInvalidCategory,
};

DisplayListOpType

enum class flutter::DisplayListOpType

strong

Enumerator
kInvalidOp
kMaxOp

Definition at line 142 of file display_list.h.

                             {
  FOR_EACH_DISPLAY_LIST_OP(DL_OP_TO_ENUM_VALUE)
 
  // empty comment to make formatter happy
  kInvalidOp,
  kMaxOp = kInvalidOp,
};

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

DlClipOp

enum class flutter::DlClipOp

strong

Enumerator
kDifference
kIntersect

Definition at line 10 of file dl_types.h.

                    {
  kDifference,
  kIntersect,
};

DlColorFilterType

enum class flutter::DlColorFilterType

strong

Enumerator
kBlend
kMatrix
kSrgbToLinearGamma
kLinearToSrgbGamma

Definition at line 19 of file dl_color_filter.h.

                             {
  kBlend,
  kMatrix,
  kSrgbToLinearGamma,
  kLinearToSrgbGamma,
};

DlColorSourceType

enum class flutter::DlColorSourceType

strong

Enumerator
kImage
kLinearGradient
kRadialGradient
kConicalGradient
kSweepGradient
kRuntimeEffect

Definition at line 35 of file dl_color_source.h.

                             {
  kImage,
  kLinearGradient,
  kRadialGradient,
  kConicalGradient,
  kSweepGradient,
  kRuntimeEffect,
};

DlColorSpace

enum class flutter::DlColorSpace

strong

Enumerator
kSRGB
kExtendedSRGB
kDisplayP3

Definition at line 13 of file dl_color.h.

{ kSRGB = 0, kExtendedSRGB = 1, kDisplayP3 = 2 };

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
kRuntimeEffect
kColorFilter
kCompose
kLocalMatrix

Definition at line 26 of file dl_image_filter.h.

                             {
  kBlur,
  kDilate,
  kErode,
  kMatrix,
  kRuntimeEffect,
  kColorFilter,
  kCompose,
  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 };

DlPointMode

enum class flutter::DlPointMode

strong

Enumerator
kPoints	draw each point separately
kLines	draw each separate pair of points as a line segment
kPolygon	draw each pair of overlapping points as a line segment

Definition at line 15 of file dl_types.h.

                       {
  kPoints,   //!< draw each point separately
  kLines,    //!< draw each separate pair of points as a line segment
  kPolygon,  //!< draw each pair of overlapping points as a line segment
};

DlSrcRectConstraint

enum class flutter::DlSrcRectConstraint

strong

Enumerator
kStrict
kFast

Definition at line 21 of file dl_types.h.

                               {
  kStrict,
  kFast,
};

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

FlutterGpuPreference

enum class flutter::FlutterGpuPreference

strong

Enumerator
NoPreference
LowPowerPreference

Definition at line 20 of file flutter_project_bundle.h.

                                {
  NoPreference,
  LowPowerPreference,
};

FlutterUIThreadPolicy

enum class flutter::FlutterUIThreadPolicy

strong

Enumerator
Default
RunOnPlatformThread
RunOnSeparateThread

Definition at line 25 of file flutter_project_bundle.h.

                                 {
  Default,
  RunOnPlatformThread,
  RunOnSeparateThread,
};

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 64 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
};

GpuPreference

enum class flutter::GpuPreference

strong

Enumerator
NoPreference
LowPowerPreference

Definition at line 14 of file dart_project.h.

                         {
  // No preference.
  NoPreference,
  // Prefer energy efficiency over performance, such as an integrated GPU.
  // This falls back to a high performance GPU if no low power GPU is
  // available.
  LowPowerPreference,
};

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

LayoutUpdateMode

enum class flutter::LayoutUpdateMode

strong

Enumerator
kSync
kAsync

Definition at line 39 of file surface_texture_external_texture_vk_impeller.cc.

                            {
  kSync,
  kAsync,
};

MaskFilterType

enum flutter::MaskFilterType

Enumerator
kNull
kBlur

Definition at line 61 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 37 of file gpu_surface_metal_delegate.h.

{ kMTLTexture, kCAMetalLayer };

MutatorType

enum class flutter::MutatorType

strong

Enumerator
kClipRect
kClipRRect
kClipRSE
kClipPath
kTransform
kOpacity
kBackdropFilter

Definition at line 33 of file embedded_views.h.

                       {
  kClipRect,
  kClipRRect,
  kClipRSE,
  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 266 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 74 of file raster_cache_key.h.

{ kLayerMetrics, kDisplayListMetrics };

RasterCacheKeyType

enum class flutter::RasterCacheKeyType

strong

Enumerator
kLayer
kDisplayList
kLayerChildren

Definition at line 24 of file raster_cache_key.h.

{ kLayer, kDisplayList, kLayerChildren };

RasterCacheLayerStrategy

enum class flutter::RasterCacheLayerStrategy

strong

Enumerator
kLayer
kLayerChildren

Definition at line 28 of file raster_cache.h.

{ kLayer, kLayerChildren };

RasterStatus

enum class flutter::RasterStatus

strong

Enumerator
kSuccess
kResubmit
kSkipAndRetry

Definition at line 26 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
kScrollToOffset
kExpand
kCollapse

Definition at line 23 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,
  kScrollToOffset = 1 << 23,
  kExpand = 1 << 24,
  kCollapse = 1 << 25,
};

SemanticsCheckState

enum class flutter::SemanticsCheckState : int32_t

strong

Enumerator
kNone
kTrue
kFalse
kMixed

Definition at line 18 of file semantics_flags.h.

                               : int32_t {
  kNone = 0,
  kTrue = 1,
  kFalse = 2,
  kMixed = 3,
};

SemanticsRole

enum class flutter::SemanticsRole : int32_t

strong

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

Warning

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

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

Enumerator
kNone
kTab
kTabBar
kTabPanel
kDialog
kAlertDialog
kTable
kCell
kRow
kColumnHeader
kDragHandle
kSpinButton
kComboBox
kMenuBar
kMenu
kMenuItem
kMenuItemCheckbox
kMenuItemRadio
kList
kListItem
kForm
kTooltip
kLoadingSpinner
kProgressBar
kHotKey
kRadioGroup
kStatus
kAlert
kComplementary
kContentInfo
kMain
kNavigation
kRegion

Definition at line 74 of file semantics_node.h.

                         : int32_t {
  kNone = 0,
  kTab = 1,
  kTabBar = 2,
  kTabPanel = 3,
  kDialog = 4,
  kAlertDialog = 5,
  kTable = 6,
  kCell = 7,
  kRow = 8,
  kColumnHeader = 9,
  kDragHandle = 10,
  kSpinButton = 11,
  kComboBox = 12,
  kMenuBar = 13,
  kMenu = 14,
  kMenuItem = 15,
  kMenuItemCheckbox = 16,
  kMenuItemRadio = 17,
  kList = 18,
  kListItem = 19,
  kForm = 20,
  kTooltip = 21,
  kLoadingSpinner = 22,
  kProgressBar = 23,
  kHotKey = 24,
  kRadioGroup = 25,
  kStatus = 26,
  kAlert = 27,
  kComplementary = 28,
  kContentInfo = 29,
  kMain = 30,
  kNavigation = 31,
  kRegion = 32,
};

SemanticsTristate

enum class flutter::SemanticsTristate : int32_t

strong

Enumerator
kNone
kTrue
kFalse

Definition at line 13 of file semantics_flags.h.

                             : int32_t {
  kNone = 0,
  kTrue = 1,
  kFalse = 2,
};

SemanticsValidationResult

enum class flutter::SemanticsValidationResult : int32_t

strong

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

Warning

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

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

Enumerator
kNone
kValid
kInvalid

Definition at line 116 of file semantics_node.h.

                                     : int32_t {
  kNone = 0,
  kValid = 1,
  kInvalid = 2,
};

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

UIThreadPolicy

enum class flutter::UIThreadPolicy

strong

Enumerator
Default
RunOnPlatformThread
RunOnSeparateThread

Definition at line 24 of file dart_project.h.

                          {
  // Default value. Currently will run the UI isolate on separate thread,
  // later will be changed to running the UI isolate on platform thread.
  Default,
  // Run the UI isolate on platform thread.
  RunOnPlatformThread,
  // Run the UI isolate on a separate thread.
  RunOnSeparateThread,
};

ViewFocusDirection

enum class flutter::ViewFocusDirection : int64_t

strong

Enumerator
kUndefined
kForward
kBackward

Definition at line 22 of file view_focus.h.

                              : int64_t {
  kUndefined = 0,
  kForward,
  kBackward,
};

ViewFocusState

enum class flutter::ViewFocusState : int64_t

strong

Enumerator
kUnfocused
kFocused

Definition at line 14 of file view_focus.h.

                          : int64_t {
  kUnfocused = 0,
  kFocused,
};

WindowArchetype

enum class flutter::WindowArchetype

strong

Enumerator
kRegular
kDialog

Definition at line 11 of file windowing.h.

                           {
  // Regular top-level window.
  kRegular,
 
  // Dialog window.
  kDialog,
};

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 35 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::kNotEfficiency);
      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::kNotEfficiency);
      // 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";
      }
  }
}

References FML_LOG, fml::Thread::kBackground, fml::Thread::kDisplay, fml::kEfficiency, fml::kNotEfficiency, fml::kNotPerformance, fml::Thread::kRaster, fml::Thread::ThreadConfig::priority, fml::RequestAffinity(), and fml::Thread::SetCurrentThreadName().

Referenced by flutter::AndroidShellHolder::AndroidShellHolder().

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";
  }
}

References kDetached, kHidden, kInactive, kPaused, and kResumed.

Referenced by flutter::WindowsLifecycleManager::SetLifecycleState().

AreRectsEqual()

bool flutter::AreRectsEqual	(	const RECT &	a,
		const RECT &	b
	)

Definition at line 19 of file rect_helper.h.

                                                 {
  return a.left == b.left && a.top == b.top && a.right == b.right &&
         a.bottom == b.bottom;
}

Referenced by flutter::HostWindow::SetFullscreen().

AttachJNI()

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

static

Definition at line 184 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,
      FlutterMain::Get().GetAndroidRenderingAPI());
  if (shell_holder->IsValid()) {
    return reinterpret_cast<jlong>(shell_holder.release());
  } else {
    return 0;
  }
}

References flutter::FlutterMain::Get().

Referenced by RegisterApi().

BENCHMARK() [1/3]

flutter::BENCHMARK

(

BM_ShellInitialization

)

BENCHMARK() [2/3]

flutter::BENCHMARK

(

BM_ShellInitializationAndShutdown

)

BENCHMARK() [3/3]

flutter::BENCHMARK

(

BM_ShellShutdown

)

BENCHMARK_CAPTURE() [1/83]

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

BENCHMARK_CAPTURE() [2/83]

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

BENCHMARK_CAPTURE() [3/83]

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

BENCHMARK_CAPTURE() [4/83]

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

BENCHMARK_CAPTURE() [5/83]

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

BENCHMARK_CAPTURE() [6/83]

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

BENCHMARK_CAPTURE() [7/83]

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

BENCHMARK_CAPTURE() [8/83]

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

BENCHMARK_CAPTURE() [9/83]

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

BENCHMARK_CAPTURE() [10/83]

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

BENCHMARK_CAPTURE() [11/83]

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

BENCHMARK_CAPTURE() [12/83]

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

BENCHMARK_CAPTURE() [13/83]

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

BENCHMARK_CAPTURE() [14/83]

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

BENCHMARK_CAPTURE() [15/83]

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

BENCHMARK_CAPTURE() [16/83]

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

BENCHMARK_CAPTURE() [17/83]

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

BENCHMARK_CAPTURE() [18/83]

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

BENCHMARK_CAPTURE() [19/83]

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

BENCHMARK_CAPTURE() [20/83]

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

BENCHMARK_CAPTURE() [21/83]

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

BENCHMARK_CAPTURE() [22/83]

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

BENCHMARK_CAPTURE() [23/83]

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

BENCHMARK_CAPTURE() [24/83]

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

BENCHMARK_CAPTURE() [25/83]

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

BENCHMARK_CAPTURE() [26/83]

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

BENCHMARK_CAPTURE() [27/83]

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

BENCHMARK_CAPTURE() [28/83]

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

BENCHMARK_CAPTURE() [29/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchByIndexDefault	,
		kDefaultNoRtree	,
		DisplayListDispatchBenchmarkType::kDefaultNoRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [30/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchByIteratorDefault	,
		kDefaultNoRtree	,
		DisplayListDispatchBenchmarkType::kDefaultNoRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [31/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchByVectorCull	,
		kCulledWithRtree	,
		DisplayListDispatchBenchmarkType::kCulledWithRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [32/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchByVectorDefault	,
		kDefaultNoRtree	,
		DisplayListDispatchBenchmarkType::kDefaultNoRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [33/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchCull	,
		kCulledWithRtree	,
		DisplayListDispatchBenchmarkType::kCulledWithRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [34/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchDefault	,
		kDefaultNoRtree	,
		DisplayListDispatchBenchmarkType::kDefaultNoRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [35/83]

flutter::BENCHMARK_CAPTURE	(	BM_DisplayListDispatchDefault	,
		kDefaultWithRtree	,
		DisplayListDispatchBenchmarkType::kDefaultWithRtree
	)		-> Unit(benchmark::kMicrosecond)

BENCHMARK_CAPTURE() [36/83]

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

BENCHMARK_CAPTURE() [37/83]

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

BENCHMARK_CAPTURE() [38/83]

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

BENCHMARK_CAPTURE() [39/83]

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

BENCHMARK_CAPTURE() [40/83]

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

BENCHMARK_CAPTURE() [41/83]

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

BENCHMARK_CAPTURE() [42/83]

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

BENCHMARK_CAPTURE() [43/83]

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

BENCHMARK_CAPTURE() [44/83]

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

BENCHMARK_CAPTURE() [45/83]

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

BENCHMARK_CAPTURE() [46/83]

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

BENCHMARK_CAPTURE() [47/83]

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

BENCHMARK_CAPTURE() [48/83]

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

BENCHMARK_CAPTURE() [49/83]

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

BENCHMARK_CAPTURE() [50/83]

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

BENCHMARK_CAPTURE() [51/83]

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

BENCHMARK_CAPTURE() [52/83]

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

BENCHMARK_CAPTURE() [53/83]

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

BENCHMARK_CAPTURE() [54/83]

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

BENCHMARK_CAPTURE() [55/83]

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

BENCHMARK_CAPTURE() [56/83]

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

BENCHMARK_CAPTURE() [57/83]

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

BENCHMARK_CAPTURE() [58/83]

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

BENCHMARK_CAPTURE() [59/83]

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

BENCHMARK_CAPTURE() [60/83]

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

BENCHMARK_CAPTURE() [61/83]

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

BENCHMARK_CAPTURE() [62/83]

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

BENCHMARK_CAPTURE() [63/83]

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

BENCHMARK_CAPTURE() [64/83]

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

BENCHMARK_CAPTURE() [65/83]

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

BENCHMARK_CAPTURE() [66/83]

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

BENCHMARK_CAPTURE() [67/83]

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

BENCHMARK_CAPTURE() [68/83]

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

BENCHMARK_CAPTURE() [69/83]

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

BENCHMARK_CAPTURE() [70/83]

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

BENCHMARK_CAPTURE() [71/83]

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

BENCHMARK_CAPTURE() [72/83]

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

BENCHMARK_CAPTURE() [73/83]

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

BENCHMARK_CAPTURE() [74/83]

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

BENCHMARK_CAPTURE() [75/83]

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

BENCHMARK_CAPTURE() [76/83]

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

BENCHMARK_CAPTURE() [77/83]

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

BENCHMARK_CAPTURE() [78/83]

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

BENCHMARK_CAPTURE() [79/83]

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

BENCHMARK_CAPTURE() [80/83]

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

BENCHMARK_CAPTURE() [81/83]

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

BENCHMARK_CAPTURE() [82/83]

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

BENCHMARK_CAPTURE() [83/83]

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
	)

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);
  }
}

References transform, and type.

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);
  }
}

References type.

BM_DisplayListBuilderDefault()

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

static

Definition at line 91 of file dl_builder_benchmarks.cc.

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

References type.

BM_DisplayListBuilderWithClipRect()

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

static

Definition at line 127 of file dl_builder_benchmarks.cc.

                                          {
  DlRect clip_bounds = DlRect::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, DlClipOp::kIntersect, true);
    InvokeAllRenderingOps(builder);
    Complete(builder, type);
  }
}

References flutter::DisplayListBuilder::ClipRect(), kIntersect, impeller::TRect< Scalar >::MakeLTRB(), and type.

BM_DisplayListBuilderWithGlobalSaveLayer()

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

static

Definition at line 140 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(std::nullopt, 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);
  }
}

References DisplayListBuilderBenchmarkAccessor(), i, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DisplayListBuilder::Translate(), and type.

BM_DisplayListBuilderWithPerspective()

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

static

Definition at line 114 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);
  }
}

References flutter::DisplayListBuilder::TransformFullPerspective(), and type.

BM_DisplayListBuilderWithSaveLayer()

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

static

Definition at line 162 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(std::nullopt, nullptr);
        invocation.Invoke(receiver);
        builder.Restore();
      }
    }
    Complete(builder, type);
  }
}

References DisplayListBuilderBenchmarkAccessor(), i, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and type.

BM_DisplayListBuilderWithSaveLayerAndImageFilter()

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

static

Definition at line 181 of file dl_builder_benchmarks.cc.

                                          {
  DlPaint layer_paint;
  layer_paint.setImageFilter(&testing::kTestBlurImageFilter1);
  DlRect layer_bounds = DlRect::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);
  }
}

References DisplayListBuilderBenchmarkAccessor(), i, flutter::testing::kTestBlurImageFilter1(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setImageFilter(), and type.

BM_DisplayListBuilderWithScaleAndTranslate()

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

static

Definition at line 101 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);
  }
}

References flutter::DisplayListBuilder::Scale(), flutter::DisplayListBuilder::Translate(), and type.

BM_DisplayListDispatchByIndexDefault()

static void flutter::BM_DisplayListDispatchByIndexDefault ( benchmark::State &  state, DisplayListDispatchBenchmarkType  type  )

static

Definition at line 223 of file dl_builder_benchmarks.cc.

                                           {
  bool prepare_rtree = NeedPrepareRTree(type);
  DisplayListBuilder builder(prepare_rtree);
  for (int i = 0; i < 5; i++) {
    InvokeAllOps(builder);
  }
  auto display_list = builder.Build();
  DlOpReceiverIgnore receiver;
  while (state.KeepRunning()) {
    DlIndex end = display_list->GetRecordCount();
    for (DlIndex i = 0u; i < end; i++) {
      display_list->Dispatch(receiver, i);
    }
  }
}

References flutter::DisplayListBuilder::Build(), end, i, and type.

BM_DisplayListDispatchByIteratorDefault()

static void flutter::BM_DisplayListDispatchByIteratorDefault ( benchmark::State &  state, DisplayListDispatchBenchmarkType  type  )

static

Definition at line 241 of file dl_builder_benchmarks.cc.

                                           {
  bool prepare_rtree = NeedPrepareRTree(type);
  DisplayListBuilder builder(prepare_rtree);
  for (int i = 0; i < 5; i++) {
    InvokeAllOps(builder);
  }
  auto display_list = builder.Build();
  DlOpReceiverIgnore receiver;
  while (state.KeepRunning()) {
    for (DlIndex i : *display_list) {
      display_list->Dispatch(receiver, i);
    }
  }
}

References flutter::DisplayListBuilder::Build(), i, and type.

BM_DisplayListDispatchByVectorCull()

static void flutter::BM_DisplayListDispatchByVectorCull ( benchmark::State &  state, DisplayListDispatchBenchmarkType  type  )

static

Definition at line 293 of file dl_builder_benchmarks.cc.

                                           {
  bool prepare_rtree = NeedPrepareRTree(type);
  DisplayListBuilder builder(prepare_rtree);
  for (int i = 0; i < 5; i++) {
    InvokeAllOps(builder);
  }
  auto display_list = builder.Build();
  DlRect rect = DlRect::MakeLTRB(0, 0, 100, 100);
  EXPECT_FALSE(rect.Contains(display_list->GetBounds()));
  DlOpReceiverIgnore receiver;
  while (state.KeepRunning()) {
    std::vector<DlIndex> indices = display_list->GetCulledIndices(rect);
    for (DlIndex index : indices) {
      display_list->Dispatch(receiver, index);
    }
  }
}

References flutter::DisplayListBuilder::Build(), impeller::TRect< T >::Contains(), i, impeller::TRect< Scalar >::MakeLTRB(), and type.

BM_DisplayListDispatchByVectorDefault()

static void flutter::BM_DisplayListDispatchByVectorDefault ( benchmark::State &  state, DisplayListDispatchBenchmarkType  type  )

static

Definition at line 258 of file dl_builder_benchmarks.cc.

                                           {
  bool prepare_rtree = NeedPrepareRTree(type);
  DisplayListBuilder builder(prepare_rtree);
  for (int i = 0; i < 5; i++) {
    InvokeAllOps(builder);
  }
  auto display_list = builder.Build();
  DlOpReceiverIgnore receiver;
  while (state.KeepRunning()) {
    std::vector<DlIndex> indices =
        display_list->GetCulledIndices(display_list->GetBounds());
    for (DlIndex index : indices) {
      display_list->Dispatch(receiver, index);
    }
  }
}

References flutter::DisplayListBuilder::Build(), i, and type.

BM_DisplayListDispatchCull()

static void flutter::BM_DisplayListDispatchCull ( benchmark::State &  state, DisplayListDispatchBenchmarkType  type  )

static

Definition at line 277 of file dl_builder_benchmarks.cc.

                                                                              {
  bool prepare_rtree = NeedPrepareRTree(type);
  DisplayListBuilder builder(prepare_rtree);
  for (int i = 0; i < 5; i++) {
    InvokeAllOps(builder);
  }
  auto display_list = builder.Build();
  DlRect rect = DlRect::MakeLTRB(0, 0, 100, 100);
  EXPECT_FALSE(rect.Contains(display_list->GetBounds()));
  DlOpReceiverIgnore receiver;
  while (state.KeepRunning()) {
    display_list->Dispatch(receiver, rect);
  }
}

References flutter::DisplayListBuilder::Build(), impeller::TRect< T >::Contains(), i, impeller::TRect< Scalar >::MakeLTRB(), and type.

BM_DisplayListDispatchDefault()

static void flutter::BM_DisplayListDispatchDefault ( benchmark::State &  state, DisplayListDispatchBenchmarkType  type  )

static

Definition at line 208 of file dl_builder_benchmarks.cc.

                                           {
  bool prepare_rtree = NeedPrepareRTree(type);
  DisplayListBuilder builder(prepare_rtree);
  for (int i = 0; i < 5; i++) {
    InvokeAllOps(builder);
  }
  auto display_list = builder.Build();
  DlOpReceiverIgnore receiver;
  while (state.KeepRunning()) {
    display_list->Dispatch(receiver);
  }
}

References flutter::DisplayListBuilder::Build(), i, and type.

BM_DlRegion_FromRects()

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

static

Definition at line 268 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 276 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 302 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 314 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 284 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);
  }
}

References transform, and type.

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);
  }
}

References transform, and type.

BM_PlatformMessageResponseDartComplete()

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

static

Definition at line 21 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();
  }
}

References flutter::DartVMRef::Create(), flutter::testing::DartFixture::CreateSettingsForFixture(), data, FML_CHECK, flutter::testing::GetDefaultKernelFilePath(), flutter::TaskRunners::GetUITaskRunner(), flutter::ThreadHost::io_thread, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, message, flutter::ThreadHost::platform_thread, fml::TaskRunner::PostTask(), flutter::ThreadHost::raster_thread, flutter::testing::RunDartCodeInIsolate(), and flutter::ThreadHost::ui_thread.

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);
  }
}

References transform, and type.

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

References transform, and type.

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);
  }
}

References transform, and type.

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);
  }
}

References transform, and type.

BM_ShellInitialization()

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

static

Definition at line 101 of file shell_benchmarks.cc.

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

References StartupAndShutdownShell().

BM_ShellInitializationAndShutdown()

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

static

Definition at line 117 of file shell_benchmarks.cc.

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

References StartupAndShutdownShell().

BM_ShellShutdown()

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

static

Definition at line 109 of file shell_benchmarks.cc.

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

References StartupAndShutdownShell().

BM_SkRegion_FromRects()

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

static

Definition at line 272 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 280 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 308 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 319 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 293 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);
  }
}

References transform, and type.

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);
  }
}

References transform, and type.

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);
}

References FML_CHECK, i, points, transform, and type.

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);
  }
}

References transform, and type.

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

References transform, and type.

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(DlPoint);
  if (flags.has_texture_coordinates) {
    needed += vertex_count * sizeof(DlPoint);
  }
  if (flags.has_colors) {
    needed += vertex_count * sizeof(DlColor);
  }
  if (index_count > 0) {
    needed += index_count * sizeof(uint16_t);
  }
  return needed;
}

Referenced by flutter::DlVertices::Builder::Builder(), and flutter::DlVertices::size().

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);
  }
}

References flutter::MessageCodec< T >::DecodeMessage(), flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), and value.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

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);
}

References flutter::MessageCodec< T >::DecodeMessage(), flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), and value.

Referenced by TEST().

ChooseCompatibleAlphaType()

static SkAlphaType flutter::ChooseCompatibleAlphaType ( SkAlphaType  type )

static

Definition at line 127 of file image_decoder_impeller.cc.

                                                               {
  return type;
}

References type.

Referenced by flutter::ImageDecoderImpeller::DecompressTexture().

ChooseCompatibleColorType()

static SkColorType flutter::ChooseCompatibleColorType ( SkColorType  type )

static

Definition at line 118 of file image_decoder_impeller.cc.

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

References type.

Referenced by flutter::ImageDecoderImpeller::DecompressTexture().

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

Referenced by flutter::AndroidContextGLSkia::AndroidContextGLSkia().

CleanupMessageData()

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

static

Definition at line 484 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

Close()

API void flutter::Close

(

SkPath *

path

)

Definition at line 36 of file path_ops.cc.

                         {
  path->close();
}

References path.

CommandLineFromNSProcessInfo()

fml::CommandLine flutter::CommandLineFromNSProcessInfo

(

NSProcessInfo *

processInfoOrNil = nil

)

Definition at line 13 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());
}

References fml::CommandLineFromIterators().

Referenced by FlutterDartProject::defaultBundleIdentifier.

CompareOps()

static bool flutter::CompareOps ( const DisplayListStorage &  storageA, const std::vector< size_t > &  offsetsA, const DisplayListStorage &  storageB, const std::vector< size_t > &  offsetsB  )

static

Definition at line 401 of file display_list.cc.

                                                          {
  const uint8_t* base_a = storageA.base();
  const uint8_t* base_b = storageB.base();
  // These conditions are checked by the caller...
  FML_DCHECK(offsetsA.size() == offsetsB.size());
  FML_DCHECK(base_a != base_b);
  size_t bulk_start = 0u;
  for (size_t i = 0; i < offsetsA.size(); i++) {
    size_t offset = offsetsA[i];
    FML_DCHECK(offsetsB[i] == offset);
    auto opA = reinterpret_cast<const DLOp*>(base_a + offset);
    auto opB = reinterpret_cast<const DLOp*>(base_b + offset);
    if (opA->type != opB->type) {
      return false;
    }
    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)
 
#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
        if (bulk_start < offset) {
          const uint8_t* bulk_start_a = base_a + bulk_start;
          const uint8_t* bulk_start_b = base_b + bulk_start;
          if (memcmp(bulk_start_a, bulk_start_b, offset - bulk_start) != 0) {
            return false;
          }
        }
        bulk_start =
            i + 1 < offsetsA.size() ? offsetsA[i + 1] : storageA.size();
        break;
    }
  }
  if (bulk_start < storageA.size()) {
    // Perform a final bulk compare if we have remaining bytes waiting
    const uint8_t* bulk_start_a = base_a + bulk_start;
    const uint8_t* bulk_start_b = base_b + bulk_start;
    if (memcmp(bulk_start_a, bulk_start_b, storageA.size() - bulk_start) != 0) {
      return false;
    }
  }
  return true;
}

References flutter::DisplayListStorage::base(), DL_OP_EQUALS, FML_DCHECK, FOR_EACH_DISPLAY_LIST_OP, i, kEqual, kNotEqual, kUseBulkCompare, and flutter::DisplayListStorage::size().

Referenced by flutter::DisplayList::Equals().

compute_bounds()

static DlRect flutter::compute_bounds ( const DlPoint *  points, int  count  )

static

Definition at line 92 of file dl_vertices.cc.

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

References flutter::AccumulationRect::accumulate(), flutter::AccumulationRect::GetBounds(), i, and points.

Referenced by flutter::DlVertices::Builder::build().

ConfigureShell()

static void flutter::ConfigureShell ( Shell *  shell )

static

Definition at line 128 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;
  metrics.physical_min_width_constraint = physical_width;
  metrics.physical_max_width_constraint = physical_width;
  metrics.physical_min_height_constraint = physical_height;
  metrics.physical_max_height_constraint = physical_height;
  shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId, metrics);
}

References flutter::ViewportMetrics::device_pixel_ratio, displays, flutter::Shell::GetPlatformView(), kImplicitViewId, and flutter::Shell::OnDisplayUpdates().

Referenced by RunTester(), and Spawn().

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

References FML_DCHECK.

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

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(resource_context.get())) {
      // 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)]() {});
      }
    });
  });
}

References ConvertToRasterUsingResourceContext(), FML_LOG, fml::WeakPtr< T >::get(), image, and flutter::DlImage::kRaster.

ConvertMappingToNSData()

NSData * flutter::ConvertMappingToNSData

(

fml::MallocMapping

buffer

)

Definition at line 34 of file buffer_conversions.mm.

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

References buffer, length, fml::RefCountedThreadSafe< T >::Release(), and size.

Referenced by flutter::PlatformMessageHandlerIos::HandlePlatformMessage().

ConvertMutation() [1/4]

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

static

Definition at line 119 of file embedder_layers.cc.

                            {
  FlutterPlatformViewMutation mutation = {};
  mutation.type = kFlutterPlatformViewMutationTypeTransformation;
  mutation.transformation.scaleX = matrix.m[0];
  mutation.transformation.skewX = matrix.m[4];
  mutation.transformation.transX = matrix.m[12];
  mutation.transformation.skewY = matrix.m[1];
  mutation.transformation.scaleY = matrix.m[5];
  mutation.transformation.transY = matrix.m[13];
  mutation.transformation.pers0 = matrix.m[3];
  mutation.transformation.pers1 = matrix.m[7];
  mutation.transformation.pers2 = matrix.m[15];
  return std::make_unique<FlutterPlatformViewMutation>(mutation);
}

References kFlutterPlatformViewMutationTypeTransformation, impeller::Matrix::m, FlutterTransformation::pers0, FlutterTransformation::pers1, FlutterTransformation::pers2, FlutterTransformation::scaleX, FlutterTransformation::scaleY, FlutterTransformation::skewX, FlutterTransformation::skewY, FlutterPlatformViewMutation::transformation, FlutterTransformation::transX, FlutterTransformation::transY, and FlutterPlatformViewMutation::type.

ConvertMutation() [2/4]

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

static

Definition at line 80 of file embedder_layers.cc.

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

References FlutterRect::bottom, FlutterPlatformViewMutation::clip_rect, impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), kFlutterPlatformViewMutationTypeClipRect, FlutterRect::left, FlutterRect::right, FlutterRect::top, and FlutterPlatformViewMutation::type.

ConvertMutation() [3/4]

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

static

Definition at line 98 of file embedder_layers.cc.

                              {
  FlutterPlatformViewMutation mutation = {};
  mutation.type = kFlutterPlatformViewMutationTypeClipRoundedRect;
  const auto& rect = rrect.GetBounds();
  mutation.clip_rounded_rect.rect.left = rect.GetLeft();
  mutation.clip_rounded_rect.rect.top = rect.GetTop();
  mutation.clip_rounded_rect.rect.right = rect.GetRight();
  mutation.clip_rounded_rect.rect.bottom = rect.GetBottom();
  const auto& radii = rrect.GetRadii();
  mutation.clip_rounded_rect.upper_left_corner_radius =
      ConvertSize(radii.top_left);
  mutation.clip_rounded_rect.upper_right_corner_radius =
      ConvertSize(radii.top_right);
  mutation.clip_rounded_rect.lower_right_corner_radius =
      ConvertSize(radii.bottom_right);
  mutation.clip_rounded_rect.lower_left_corner_radius =
      ConvertSize(radii.bottom_left);
  return std::make_unique<FlutterPlatformViewMutation>(mutation);
}

References FlutterRect::bottom, FlutterPlatformViewMutation::clip_rounded_rect, ConvertSize(), impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), kFlutterPlatformViewMutationTypeClipRoundedRect, FlutterRect::left, FlutterRoundedRect::lower_left_corner_radius, FlutterRoundedRect::lower_right_corner_radius, FlutterRoundedRect::rect, FlutterRect::right, FlutterRect::top, FlutterPlatformViewMutation::type, FlutterRoundedRect::upper_left_corner_radius, and FlutterRoundedRect::upper_right_corner_radius.

ConvertMutation() [4/4]

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

static

Definition at line 72 of file embedder_layers.cc.

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

References kFlutterPlatformViewMutationTypeOpacity, FlutterPlatformViewMutation::opacity, and FlutterPlatformViewMutation::type.

Referenced by flutter::EmbedderLayers::PushPlatformViewLayer().

ConvertNSDataToMappingPtr()

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

(

NSData *

data

)

Definition at line 39 of file buffer_conversions.mm.

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

References data.

Referenced by flutter::PlatformMessageHandlerIos::HandlePlatformMessage().

ConvertSize()

static FlutterSize flutter::ConvertSize ( const DlSize &  vector )

static

Definition at line 91 of file embedder_layers.cc.

                                                     {
  FlutterSize size = {};
  size.width = vector.width;
  size.height = vector.height;
  return size;
}

References impeller::TSize< T >::height, size, impeller::TSize< T >::width, and FlutterSize::width.

Referenced by ConvertMutation().

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

References FlutterLocale::country_code, FlutterLocale::language_code, FlutterLocale::script_code, FlutterLocale::struct_size, and FlutterLocale::variant_code.

Referenced by SetUpLocales().

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(resource_context.get());
}

References FML_LOG, fml::WeakPtr< T >::get(), image, and surface.

Referenced by ConvertImageToRasterSkia(), and flutter::testing::TEST_F().

CopyMappingPtrToNSData()

NSData * flutter::CopyMappingPtrToNSData

(

std::unique_ptr< fml::Mapping >

mapping

)

Definition at line 43 of file buffer_conversions.mm.

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

References length.

Referenced by flutter::PlatformMessageResponseDarwin::Complete().

CopyNSDataToMapping()

fml::MallocMapping flutter::CopyNSDataToMapping

(

NSData *

data

)

Definition at line 29 of file buffer_conversions.mm.

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

References fml::MallocMapping::Copy(), and data.

CopyV() [1/2]

static void flutter::CopyV ( void *  dst )

static

Definition at line 23 of file dl_builder.cc.

{}

Referenced by CopyV().

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 26 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)...);
}

References CopyV(), and FML_DCHECK.

CreateAndroidContext()

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

static

Definition at line 109 of file platform_view_android.cc.

                                                   {
  switch (android_rendering_api) {
#if !SLIMPELLER
    case AndroidRenderingAPI::kSoftware:
      return std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
    case AndroidRenderingAPI::kSkiaOpenGLES:
      return std::make_unique<AndroidContextGLSkia>(
          fml::MakeRefCounted<AndroidEnvironmentGL>(),  //
          task_runners                                  //
      );
#endif  // !SLIMPELLER
    case AndroidRenderingAPI::kImpellerVulkan:
      return std::make_unique<AndroidContextVKImpeller>(settings);
    case AndroidRenderingAPI::kImpellerOpenGLES:
      return std::make_unique<AndroidContextGLImpeller>(
          std::make_unique<impeller::egl::Display>(),
          enable_opengl_gpu_tracing);
    case AndroidRenderingAPI::kImpellerAutoselect:
      // Determine if we're using GL or Vulkan.
      return std::make_unique<AndroidContextDynamicImpeller>(settings);
  }
  FML_UNREACHABLE();
}

References FML_UNREACHABLE, kImpellerAutoselect, kImpellerOpenGLES, kImpellerVulkan, kSkiaOpenGLES, and kSoftware.

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

Referenced by flutter::AndroidContextGLSkia::AndroidContextGLSkia().

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, const 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), DlISize(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, unref_queue);
#endif  //  !SLIMPELLER
}

References FML_LOG, height, flutter::DlDeferredImageGPUSkia::Make(), flutter::DlDeferredImageGPUImpeller::Make(), and width.

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, const 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, unref_queue);
#endif  //  SLIMPELLER
}

References FML_LOG, flutter::DlDeferredImageGPUImpeller::Make(), and flutter::DlDeferredImageGPUSkia::MakeFromLayerTree().

Referenced by flutter::Picture::RasterizeToImageSync().

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 33 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;
 
  VoidCallback destruction_callback_c = [](void* user_data) {};
  if (SAFE_ACCESS(description, destruction_callback, nullptr) != nullptr) {
    destruction_callback_c = description->destruction_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->unique_id()),
            // 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);
      },
      .destruction_callback =
          [destruction_callback_c, user_data]() {
            destruction_callback_c(user_data);
          },
  };
 
  return {true, fml::MakeRefCounted<EmbedderTaskRunner>(
                    task_runner_dispatch_table,
                    SAFE_ACCESS(description, identifier, 0u))};
}

References FlutterTaskRunnerDescription::destruction_callback, FML_LOG, FlutterTaskRunnerDescription::post_task_callback, flutter::EmbedderTaskRunner::DispatchTable::post_task_callback, FlutterTaskRunnerDescription::runs_task_on_current_thread_callback, SAFE_ACCESS, and user_data.

CreateFinishedBuildRecorder() [1/2]

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

static

Definition at line 160 of file rasterizer_unittests.cc.

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

References CreateFinishedBuildRecorder(), and fml::TimePoint::Now().

Referenced by CreateFinishedBuildRecorder(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

CreateFinishedBuildRecorder() [2/2]

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

static

Definition at line 150 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;
}

CreateFlutterViewID()

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

static

Definition at line 229 of file service_protocol.cc.

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

References handler, and kViewIdPrefx.

Referenced by flutter::ServiceProtocol::Handler::Description::Write().

CreateGLInterface()

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

static

Definition at line 84 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;
}

References FML_LOG, and IsProcResolverOpenGLES().

Referenced by flutter::GPUSurfaceGLDelegate::GetDefaultPlatformGLInterface(), and flutter::GPUSurfaceGLDelegate::GetGLInterface().

CreateImpellerContext() [1/2]

static std::shared_ptr< impeller::Context > flutter::CreateImpellerContext ( const fml::RefPtr< fml::NativeLibrary > &  vulkan_dylib, const AndroidContext::ContextSettings &  p_settings  )

static

Definition at line 18 of file android_context_vk_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),
      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 = p_settings.enable_validation;
  settings.enable_gpu_tracing = p_settings.enable_gpu_tracing;
  settings.enable_surface_control = p_settings.enable_surface_control;
  settings.flags = p_settings.impeller_flags;
 
  auto context = impeller::ContextVK::Create(std::move(settings));
 
  if (!p_settings.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).";
    }
  }
  if (context && context->GetDriverInfo()->IsKnownBadDriver()) {
    FML_LOG(INFO)
        << "Known bad Vulkan driver encountered, falling back to OpenGLES.";
    return nullptr;
  }
 
  return context;
}

References impeller::CapabilitiesVK::AreValidationsEnabled(), impeller::ContextVK::Settings::cache_directory, impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), impeller::ContextVK::Create(), impeller::ContextVK::Settings::enable_gpu_tracing, flutter::AndroidContext::ContextSettings::enable_gpu_tracing, impeller::ContextVK::Settings::enable_surface_control, flutter::AndroidContext::ContextSettings::enable_surface_control, impeller::ContextVK::Settings::enable_validation, flutter::AndroidContext::ContextSettings::enable_validation, impeller::ContextVK::Settings::flags, FML_LOG, fml::paths::GetCachesDirectory(), flutter::AndroidContext::ContextSettings::impeller_flags, impeller::ContextVK::Settings::proc_address_callback, flutter::AndroidContext::ContextSettings::quiet, impeller::ContextVK::Settings::shader_libraries_data, and VALIDATION_LOG.

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>> gles2_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),
  };
 
// To maximally reduce code size, only load the older GLES2 shaders.
#if !SLIMPELLER
  bool is_gles3 = proc_table->GetDescription()->GetGlVersion().IsAtLeast(
      impeller::Version{3, 0, 0});
 
  std::vector<std::shared_ptr<fml::Mapping>> gles3_shader_mappings = {
      std::make_shared<fml::NonOwnedMapping>(
          impeller_entity_shaders_gles3_data,
          impeller_entity_shaders_gles3_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_framebuffer_blend_shaders_gles3_data,
          impeller_framebuffer_blend_shaders_gles3_length),
  };
 
  auto context = impeller::ContextGLES::Create(
      impeller::Flags{}, std::move(proc_table),
      is_gles3 ? gles3_shader_mappings : gles2_shader_mappings,
      enable_gpu_tracing);
#else
  auto context =
      impeller::ContextGLES::Create(impeller::Flags{}, std::move(proc_table),
                                    gles2_shader_mappings, enable_gpu_tracing);
#endif  // !SLIMPELLER
 
  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;
}

References impeller::ContextGLES::Create(), impeller::egl::CreateProcAddressResolver(), and FML_LOG.

CreateIsolateID()

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

static

Definition at line 235 of file service_protocol.cc.

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

Referenced by flutter::ServiceProtocol::Handler::Description::Write().

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

References path.

CreateSnapshotSurface()

static sk_sp< SkSurface > flutter::CreateSnapshotSurface ( GrDirectContext *  surface_context, const DlISize &  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);
}

References size.

Referenced by flutter::OffscreenSurface::OffscreenSurface().

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);
}

References path.

DartFileModifiedCallback()

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

Definition at line 121 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;
}

References fml::TimeDelta::FromMilliseconds(), fml::TimeDelta::FromSeconds(), kFileUriPrefix, kFileUriPrefixLength, and path.

DartFileRecorderArgs()

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

static

Definition at line 83 of file dart_vm.cc.

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

References path.

DartOldGenHeapSizeArgs()

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

static

Definition at line 112 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 295 of file dart_runtime_hooks.cc.

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

References FindAndInvokeDartPluginRegistrant().

DartTimelineTicksSinceEpoch()

fml::TimePoint flutter::DartTimelineTicksSinceEpoch

(

)

Definition at line 34 of file dart_timestamp_provider.cc.

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

References flutter::DartTimestampProvider::Instance(), and flutter::DartTimestampProvider::Now().

Referenced by DartVMInitializer::Initialize().

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;
 
  SkSpan<uint8_t> outVerbs(data->verbs, verb_count);
  path->getVerbs(outVerbs);
  SkSpan<SkPoint> outPoints(reinterpret_cast<SkPoint*>(data->points),
                            point_count);
  path->getPoints(outPoints);
  return data;
}

References data, and path.

Referenced by flutter::ImageLRU::AddImage(), flutter::ImageLRU::Clear(), flutter::DlPath::DlPath(), flutter::DlPath::DlPath(), flutter::DlPath::~DlPath(), and flutter::ImageLRU::~ImageLRU().

decodeFontFeatures()

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

Definition at line 327 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);
  }
}

References tonic::DartByteData::data(), FML_CHECK, tonic::DartByteData::length_in_bytes(), txt::FontFeatures::SetFeature(), and value.

Referenced by flutter::ParagraphBuilder::pushStyle().

decodeFontVariations()

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

Definition at line 345 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);
  }
}

References tonic::DartByteData::data(), FML_CHECK, tonic::DartByteData::length_in_bytes(), txt::FontVariations::SetAxisValue(), and value.

Referenced by flutter::ParagraphBuilder::pushStyle().

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 int32_t* int32_data = static_cast<const int32_t*>(byte_data.data());
  int32_t mask = int32_data[0];
 
  size_t int32_count = 1;
  if (mask & kSFontWeightMask) {
    paragraph_style.strut_font_weight = int32_data[int32_count++];
  }
  if (mask & kSFontStyleMask) {
    paragraph_style.strut_font_style =
        static_cast<txt::FontStyle>(int32_data[int32_count++]);
  }
 
  paragraph_style.strut_half_leading = mask & kSLeadingDistributionMask;
 
  std::vector<float> float_data;
  float_data.resize((byte_data.length_in_bytes() / 4) - int32_count);
  memcpy(float_data.data(), int32_data + int32_count, float_data.size() * 4);
  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("");
  }
}

References tonic::DartByteData::data(), txt::ParagraphStyle::force_strut_height, tonic::DartByteData::length_in_bytes(), txt::ParagraphStyle::strut_enabled, txt::ParagraphStyle::strut_font_families, txt::ParagraphStyle::strut_font_size, txt::ParagraphStyle::strut_font_style, txt::ParagraphStyle::strut_font_weight, txt::ParagraphStyle::strut_half_leading, txt::ParagraphStyle::strut_has_height_override, txt::ParagraphStyle::strut_height, and txt::ParagraphStyle::strut_leading.

decodeTextShadows()

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

Definition at line 302 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]);
  }
}

References tonic::DartByteData::data(), FML_CHECK, and tonic::DartByteData::length_in_bytes().

Referenced by flutter::ParagraphBuilder::pushStyle().

DEF_SWITCH() [1/18]

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

References DEF_SWITCH.

DEF_SWITCH() [2/18]

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() [3/18]

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	(	DeviceVMServicePort	,
		"vm-service-port"	,
		"A custom Dart VM Service port. The default is to pick a randomly " "available open port."
	)

DEF_SWITCH() [4/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [5/18]

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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode flutter::DEF_SWITCH	(	DisableVMServicePublication	,
		"disable-vm-service-publication"	,
		"Disable mDNS Dart VM Service publication."
	)

DEF_SWITCH() [6/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [7/18]

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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode 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() [8/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [9/18]

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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring meaning that once it is new samples start overwriting the oldest ones This switch is only meaningful when set in conjunction with enable dart profiling flutter::DEF_SWITCH	(	EndlessTraceBuffer	,
		"endless-trace-buffer"	,
		"Enable an endless trace buffer. The default is a ring buffer. " "This is useful when very old events need to viewed. For	example,
		" "during application launch. Memory usage will continue to grow " "indefinitely however."
	)

DEF_SWITCH() [10/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [11/18]

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() [12/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [13/18]

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() [14/18]

it will be possible to load the file into Perfetto s trace viewer flutter::DEF_SWITCH	(	ProfileMicrotasks	,
		"profile-microtasks"	,
		"Enable collection of information about each microtask. Information " "about completed microtasks will be written to the \"Microtask\" " "timeline stream. Information about queued microtasks will be " "accessible from Dart / Flutter DevTools."
	)

DEF_SWITCH() [15/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [16/18]

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() [17/18]

it will be possible to load the file into Perfetto s trace viewer use test 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 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() [18/18]

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."
	)

DeferredComponentInstallFailure()

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

static

Definition at line 649 of file platform_view_android_jni_impl.cc.

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

References fml::jni::JavaStringToString(), and LoadLoadingUnitFailure().

Referenced by RegisterApi().

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

References data, FML_CHECK, image, and length.

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 70 of file path_ops.cc.

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

References data.

DestroyJNI()

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

static

Definition at line 198 of file platform_view_android_jni_impl.cc.

                                                                         {
  delete ANDROID_SHELL_HOLDER;
}

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

DestroyPath()

API void flutter::DestroyPath

(

SkPath *

path

)

Definition at line 14 of file path_ops.cc.

                               {
  delete path;
}

References path.

DestroyPathBuilder()

API void flutter::DestroyPathBuilder

(

SkPath *

path

)

DispatchEmptyPlatformMessage()

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

static

Definition at line 472 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER, channel, and fml::jni::JavaStringToString().

Referenced by RegisterApi().

DispatchPlatformMessage()

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

static

Definition at line 456 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER, channel, fml::jni::JavaStringToString(), and message.

Referenced by RegisterApi(), and TEST_F().

DispatchPointerDataPacket()

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

static

Definition at line 491 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));
}

References ANDROID_SHELL_HOLDER, buffer, and data.

Referenced by RegisterApi().

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 502 of file platform_view_android_jni_impl.cc.

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

References action, ANDROID_SHELL_HOLDER, and args.

Referenced by RegisterApi(), and flutter::testing::TEST().

DisplayListBuilderBenchmarkAccessor()

DlOpReceiver & flutter::DisplayListBuilderBenchmarkAccessor

(

DisplayListBuilder &

builder

)

Definition at line 11 of file dl_builder_benchmarks.cc.

                                                                               {
  return builder.asReceiver();
}

Referenced by BM_DisplayListBuilderWithGlobalSaveLayer(), BM_DisplayListBuilderWithSaveLayer(), and BM_DisplayListBuilderWithSaveLayerAndImageFilter().

DisplayListBuilderTestingAccessor()

DlOpReceiver & flutter::DisplayListBuilderTestingAccessor

(

DisplayListBuilder &

builder

)

Definition at line 36 of file display_list_unittests.cc.

                                                                             {
  return builder.asReceiver();
}

Referenced by flutter::testing::DisplayListTestBase< BaseT >::ToReceiver().

DisplayListBuilderTestingAttributes()

DlPaint flutter::DisplayListBuilderTestingAttributes

(

DisplayListBuilder &

builder

)

Definition at line 40 of file display_list_unittests.cc.

                                                                         {
  return builder.CurrentAttributes();
}

Referenced by flutter::testing::DisplayListTestBase< BaseT >::check_defaults().

DisplayListBuilderTestingLastOpIndex()

int flutter::DisplayListBuilderTestingLastOpIndex

(

DisplayListBuilder &

builder

)

Definition at line 44 of file display_list_unittests.cc.

                                                                      {
  return builder.LastOpIndex();
}

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

DlGradientDeleter()

static void flutter::DlGradientDeleter ( void *  p )

static

Definition at line 14 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);
}

Referenced by flutter::DlColorSource::MakeConical(), flutter::DlColorSource::MakeConical(), flutter::DlColorSource::MakeLinear(), flutter::DlColorSource::MakeLinear(), flutter::DlColorSource::MakeRadial(), flutter::DlColorSource::MakeRadial(), flutter::DlColorSource::MakeSweep(), and flutter::DlColorSource::MakeSweep().

DlScalarNearlyEqual()

constexpr bool flutter::DlScalarNearlyEqual ( DlScalar  x, DlScalar  y, DlScalar  tolerance = kEhCloseEnough  )

inlineconstexpr

Definition at line 44 of file dl_geometry_types.h.

                                                                               {
  return impeller::ScalarNearlyEqual(x, y, tolerance);
}

References impeller::ScalarNearlyEqual(), x, and y.

Referenced by flutter::DlBlurImageFilter::equals_(), and flutter::testing::SaveLayerBoundsExpector::saveLayer().

DlScalarNearlyZero()

constexpr bool flutter::DlScalarNearlyZero ( DlScalar  x, DlScalar  tolerance = kEhCloseEnough  )

inlineconstexpr

Definition at line 39 of file dl_geometry_types.h.

                                                                              {
  return impeller::ScalarNearlyZero(x, tolerance);
}

References impeller::ScalarNearlyZero(), and x.

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);
}

Referenced by flutter::DlVertices::Builder::Builder().

DrawCheckerboard()

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

Definition at line 32 of file paint_utils.cc.

                                                            {
  // Draw a checkerboard
  canvas->Save();
  canvas->ClipRect(rect, DlClipOp::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);
}

References flutter::DlCanvas::ClipRect(), flutter::DlCanvas::DrawPaint(), flutter::DlCanvas::DrawRect(), kIntersect, kStroke, flutter::DlCanvas::Restore(), flutter::DlCanvas::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

Referenced by flutter::RasterCache::UpdateCacheEntry().

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

References type.

Referenced by FlutterStandardReaderWriter::readerWithData:.

EmbedderInformationCallback()

static void flutter::EmbedderInformationCallback ( Dart_EmbedderInformation *  info )

static

Definition at line 235 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);
 
#if IMPELLER_SUPPORTS_RENDERING && FML_OS_IOS_SIMULATOR
  if (canvas_image->image()->IsFakeImage()) {
    sk_sp<SkData> data = SkData::MakeEmpty();
    InvokeDataCallback(std::move(callback), data);
    return Dart_Null();
  }
#endif  // IMPELLER_SUPPORTS_RENDERING && FML_OS_IOS_SIMULATOR
 
  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();
}

References callback, flutter::UIDartState::Current(), tonic::DartState::Current(), data, format, flutter::UIDartState::GetIOManager(), flutter::TaskRunners::GetIOTaskRunner(), flutter::UIDartState::GetSnapshotDelegate(), flutter::UIDartState::GetTaskRunners(), flutter::CanvasImage::image(), image, flutter::UIDartState::IsImpellerEnabled(), fml::MakeCopyable(), and fml::TaskRunner::PostTask().

Referenced by flutter::testing::TEST_F(), and flutter::CanvasImage::toByteData().

EncodeImage() [2/2]

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

Definition at line 213 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.");
}

References format, fml::kInternal, kPNG, kRawExtendedRgba128, kRawRGBA, kRawStraightRGBA, kRawUnmodified, and TRACE_EVENT0.

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

References txt::Paragraph::TextBox::direction, EncodeTextBoxes(), i, and txt::Paragraph::TextBox::rect.

Referenced by EncodeTextBoxes(), flutter::Paragraph::getRectsForPlaceholders(), and flutter::Paragraph::getRectsForRange().

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

References character, and FML_DCHECK.

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

Equals() [1/9]

template<class T , class U >

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

Definition at line 50 of file dl_comparable.h.

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

References Equals().

Equals() [2/9]

template<class T , class U >

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

Definition at line 61 of file dl_comparable.h.

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

References Equals().

Equals() [3/9]

template<class T , class U >

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

Definition at line 30 of file dl_comparable.h.

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

References Equals().

Equals() [4/9]

template<class T , class U >

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

Definition at line 56 of file dl_comparable.h.

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

References Equals().

Equals() [5/9]

template<class T , class U >

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

Definition at line 66 of file dl_comparable.h.

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

References Equals().

Equals() [6/9]

template<class T , class U >

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

Definition at line 35 of file dl_comparable.h.

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

References Equals().

Equals() [7/9]

template<class T , class U >

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

Definition at line 40 of file dl_comparable.h.

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

References Equals().

Equals() [8/9]

template<class T , class U >

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

Definition at line 45 of file dl_comparable.h.

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

References Equals().

Equals() [9/9]

template<class T , class U >

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

Definition at line 19 of file dl_comparable.h.

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

Referenced by flutter::DrawTextOp::equals(), flutter::SaveLayerBackdropOp::equals(), flutter::SetSharedImageFilterOp::equals(), Equals(), Equals(), Equals(), Equals(), Equals(), Equals(), Equals(), Equals(), flutter::DlColorFilterImageFilter::equals_(), flutter::DlComposeImageFilter::equals_(), flutter::DlLocalMatrixImageFilter::equals_(), NotEquals(), NotEquals(), NotEquals(), NotEquals(), NotEquals(), NotEquals(), NotEquals(), NotEquals(), NotEquals(), flutter::DlPaint::operator==(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::testEquals(), flutter::testing::testEquals(), flutter::testing::TestEquals(), flutter::testing::testEquals(), flutter::testing::testNotEquals(), flutter::testing::testNotEquals(), and flutter::testing::testNotEquals().

FillAllIndices()

static void flutter::FillAllIndices ( std::vector< DlIndex > &  indices, DlIndex  size  )

static

Definition at line 363 of file display_list.cc.

                                                                      {
  indices.reserve(size);
  for (DlIndex i = 0u; i < size; i++) {
    indices.push_back(i);
  }
}

References i, and size.

Referenced by flutter::DisplayList::GetCulledIndices().

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);
}

References dart_plugin_registrant_library_override, InvokeDartPluginRegistrantIfAvailable(), and tonic::ToDart().

Referenced by DartPluginRegistrant_EnsureInitialized(), and flutter::DartIsolate::RunFromLibrary().

FirstSupportedColorType()

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

static

Definition at line 119 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;
}

References GPU_GL_RGB565, GPU_GL_RGBA4, GPU_GL_RGBA8, and RETURN_IF_RENDERABLE.

Referenced by WrapOnscreenSurface().

FlagForSwitch()

const std::string_view flutter::FlagForSwitch

(

Switch

swtch

)

Definition at line 146 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();
}

References i.

Referenced by GetSwitchValue(), main(), and SettingsFromCommandLine().

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

References FlutterStandardFieldFloat32Data, FlutterStandardFieldFloat64Data, FlutterStandardFieldInt32Data, FlutterStandardFieldInt64Data, and FlutterStandardFieldUInt8Data.

Referenced by FlutterStandardReaderWriter::readerWithData:.

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

References FlutterStandardFieldFloat32Data, FlutterStandardFieldFloat64Data, FlutterStandardFieldInt32Data, FlutterStandardFieldInt64Data, FlutterStandardFieldUInt8Data, and type.

Referenced by FlutterStandardWriter::writeValue:.

FlutterTextUtilsIsEmoji()

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

static

Definition at line 613 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

FlutterTextUtilsIsEmojiModifier()

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

static

Definition at line 619 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

FlutterTextUtilsIsEmojiModifierBase()

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

static

Definition at line 625 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

FlutterTextUtilsIsRegionalIndicator()

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

static

Definition at line 637 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

FlutterTextUtilsIsVariationSelector()

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

static

Definition at line 631 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

ForceShutdownIsolate()

EXPORTED void flutter::ForceShutdownIsolate

(

)

Definition at line 615 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));
}

References tonic::CheckAndHandleError(), FML_CHECK, FML_DCHECK, and tonic::ToDart().

GetBitmap()

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

static

Definition at line 423 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;
}

References ANDROID_SHELL_HOLDER, buffer, g_bitmap_class, g_bitmap_config_class, g_bitmap_config_value_of, g_bitmap_copy_pixels_from_buffer_method, g_bitmap_create_bitmap_method, and flutter::Rasterizer::UncompressedImage.

Referenced by RegisterApi().

GetColorSpace()

SkColorSpace * flutter::GetColorSpace ( DlCanvas *  canvas )

inline

Definition at line 24 of file layer_tree.cc.

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

References flutter::DlCanvas::GetImageInfo().

Referenced by flutter::LayerTree::Paint(), and flutter::LayerTree::Preroll().

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];
}

References FML_CHECK, kMetal, kSoftware, and METAL_IOS_VERSION_BASELINE.

GetCurrentThreadTaskRunner()

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

static

Definition at line 121 of file embedder_thread_host.cc.

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

References fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), and fml::MessageLoop::GetTaskRunner().

GetCursorFromBuffer()

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

Definition at line 186 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;
}

References buffer, GetMaskBitmaps(), height, width, and y.

GetDartVersion()

const char * flutter::GetDartVersion

(

)

Definition at line 23 of file version.cc.

                             {
  return DART_VERSION;
}

Referenced by PrintUsage().

GetDefaultPlatformData()

static PlatformData flutter::GetDefaultPlatformData ( )

static

Definition at line 76 of file android_shell_holder.cc.

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

References flutter::PlatformData::lifecycle_state.

Referenced by flutter::AndroidShellHolder::AndroidShellHolder().

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 128 of file dpi_utils.cc.

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

Referenced by FlutterDesktopGetDpiForHWND(), flutter::FlutterWindow::FlutterWindow(), flutter::HostWindow::GetWindowSizeForClientSize(), flutter::HostWindow::HandleMessage(), flutter::FlutterWindow::HandleMessage(), flutter::HostWindow::SetFullscreen(), flutter::testing::TEST(), and flutter::testing::TEST().

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 132 of file dpi_utils.cc.

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

Referenced by FlutterDesktopGetDpiForMonitor(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

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
}

References buffer, length, and MAX_PATH.

Referenced by flutter::FlutterProjectBundle::FlutterProjectBundle(), RunFlutterEngine(), and TEST().

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);
  }
}

References fml::FileMapping::CreateReadExecute(), fml::FileMapping::CreateReadOnly(), and path.

Referenced by SearchMapping().

GetFillType()

API int flutter::GetFillType

(

SkPath *

path

)

Definition at line 48 of file path_ops.cc.

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

References path.

GetFlutterContentHash()

const char * flutter::GetFlutterContentHash

(

)

Definition at line 15 of file version.cc.

                                    {
  return FLUTTER_CONTENT_HASH;
}

Referenced by PrintUsage().

GetFlutterEngineVersion()

const char * flutter::GetFlutterEngineVersion

(

)

Definition at line 11 of file version.cc.

                                      {
  return FLUTTER_ENGINE_VERSION;
}

References FLUTTER_ENGINE_VERSION.

Referenced by PrintUsage(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

GetFontFile()

const std::string & flutter::GetFontFile

(

)

Definition at line 20 of file flow_test_utils.cc.

                               {
  return gFontFile;
}

References gFontFile.

GetFunctionClassName()

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

static

Definition at line 222 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));
}

References PropagateIfError().

Referenced by flutter::DartRuntimeHooks::GetCallbackHandle().

GetFunctionLibraryUrl()

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

static

Definition at line 200 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);
}

References PropagateIfError().

Referenced by flutter::DartRuntimeHooks::GetCallbackHandle().

GetFunctionName()

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

static

Definition at line 250 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);
}

References PropagateIfError().

Referenced by flutter::DartRuntimeHooks::GetCallbackHandle().

GetGoldenDir()

const std::string & flutter::GetGoldenDir

(

)

Definition at line 12 of file flow_test_utils.cc.

                                {
  return gGoldenDir;
}

References 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;
}

Referenced by flutter::BuiltinSkiaCodecImageGenerator::BuiltinSkiaCodecImageGenerator(), and flutter::BuiltinSkiaCodecImageGenerator::BuiltinSkiaCodecImageGenerator().

GetIsSoftwareRendering()

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

static

Definition at line 532 of file platform_view_android_jni_impl.cc.

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

References flutter::Settings::enable_software_rendering, flutter::FlutterMain::Get(), and flutter::FlutterMain::GetSettings().

Referenced by RegisterApi().

GetMaskBitmaps()

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

Definition at line 230 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);
}

References x, and y.

Referenced by GetCursorFromBuffer().

GetNextPipelineTraceID()

size_t flutter::GetNextPipelineTraceID

(

)

Definition at line 9 of file pipeline.cc.

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

Referenced by flutter::Pipeline< R >::Produce(), and flutter::Pipeline< R >::ProduceIfEmpty().

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

Referenced by SetUpLocales(), and flutter::testing::TEST().

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

References GetPreferredLanguages(), and ParseLanguageName().

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

References buffer, GetPreferredLanguagesFromMUI(), and start.

Referenced by GetPreferredLanguageInfo(), and flutter::testing::TEST().

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

References buffer, and flutter::WindowsProcTable::GetThreadPreferredUILanguages().

Referenced by GetPreferredLanguages().

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(nullptr);
  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());
}

References FML_LOG.

Referenced by flutter::OffscreenSurface::GetRasterData().

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) {
    [FlutterLogger logWarning:@"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
}

References FML_CHECK, kMetal, kSoftware, and ShouldUseMetalRenderer().

GetSkiaVersion()

const char * flutter::GetSkiaVersion

(

)

Definition at line 19 of file version.cc.

                             {
  return SKIA_VERSION;
}

Referenced by PrintUsage(), and flutter::testing::TEST_F().

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

References i.

Referenced by fl_engine_start(), flutter::FlutterProjectBundle::GetSwitches(), TEST(), TEST(), TEST(), and TEST().

GetSwitchValue()

template<typename T >

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

static

Definition at line 183 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;
}

References FlagForSwitch(), fml::CommandLine::GetOptionValue(), and value.

Referenced by SettingsFromCommandLine().

GetSymbolMapping()

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

Definition at line 202 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);
}

References fml::NativeLibrary::Create(), fml::NativeLibrary::CreateForCurrentProcess(), FML_CHECK, and size.

Referenced by SettingsFromCommandLine().

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

References txt::GetDefaultFontManager().

Referenced by flutter::FontCollection::RegisterTestFonts().

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

Referenced by flutter::FontCollection::RegisterTestFonts().

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
}

References kNotNecessary.

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);
}

References buffer.

Referenced by flutter::SettingsPlugin::GetAlwaysUse24HourFormat(), and flutter::testing::TEST().

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());
}

References glyphInfoFrom().

Referenced by flutter::Paragraph::getClosestGlyphInfo(), flutter::Paragraph::getGlyphInfoAt(), and glyphInfoFrom().

HandleMessageOnHandler()

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

static

Definition at line 159 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;
}

References FML_DCHECK, handler, params, fml::TaskRunner::RunNowOrPostTask(), and fml::AutoResetWaitableEvent::Wait().

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(nullptr);
  }
 
  return ResizeRasterImage(image, SkISize::Make(target_width, target_height),
                           flow);
}

References flutter::ImageDescriptor::data(), FML_LOG, image, flutter::ImageDescriptor::image_info(), ResizeRasterImage(), flutter::ImageDescriptor::row_bytes(), fml::tracing::TraceFlow::Step(), and TRACE_EVENT0.

IMPLEMENT_WRAPPERTYPEINFO() [1/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Canvas
	)

IMPLEMENT_WRAPPERTYPEINFO() [2/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Codec
	)

IMPLEMENT_WRAPPERTYPEINFO() [3/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ColorFilter
	)

IMPLEMENT_WRAPPERTYPEINFO() [4/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		EngineLayer
	)

IMPLEMENT_WRAPPERTYPEINFO() [5/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		FragmentProgram
	)

IMPLEMENT_WRAPPERTYPEINFO() [6/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Gradient
	)

IMPLEMENT_WRAPPERTYPEINFO() [7/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImageDescriptor
	)

IMPLEMENT_WRAPPERTYPEINFO() [8/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImageFilter
	)

IMPLEMENT_WRAPPERTYPEINFO() [9/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImageShader
	)

IMPLEMENT_WRAPPERTYPEINFO() [10/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ImmutableBuffer
	)

IMPLEMENT_WRAPPERTYPEINFO() [11/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		NativeSemanticsFlags
	)

IMPLEMENT_WRAPPERTYPEINFO() [12/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		NativeStringAttribute
	)

IMPLEMENT_WRAPPERTYPEINFO() [13/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Paragraph
	)

IMPLEMENT_WRAPPERTYPEINFO() [14/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ParagraphBuilder
	)

IMPLEMENT_WRAPPERTYPEINFO() [15/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Path
	)

IMPLEMENT_WRAPPERTYPEINFO() [16/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		PathMeasure
	)

IMPLEMENT_WRAPPERTYPEINFO() [17/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Picture
	)

IMPLEMENT_WRAPPERTYPEINFO() [18/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		PictureRecorder
	)

IMPLEMENT_WRAPPERTYPEINFO() [19/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		ReusableFragmentShader
	)

IMPLEMENT_WRAPPERTYPEINFO() [20/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		RSuperellipse
	)

IMPLEMENT_WRAPPERTYPEINFO() [21/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Scene
	)

IMPLEMENT_WRAPPERTYPEINFO() [22/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SceneBuilder
	)

IMPLEMENT_WRAPPERTYPEINFO() [23/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SemanticsUpdate
	)

IMPLEMENT_WRAPPERTYPEINFO() [24/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		SemanticsUpdateBuilder
	)

IMPLEMENT_WRAPPERTYPEINFO() [25/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Shader
	)

IMPLEMENT_WRAPPERTYPEINFO() [26/26]

flutter::IMPLEMENT_WRAPPERTYPEINFO	(	ui	,
		Vertices
	)

InitDartAsync()

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

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);
 
#if !FLUTTER_RELEASE
  if (enable_microtask_profiling) {
    Dart_Handle microtask_mirror_queue_type_name =
        Dart_NewStringFromCString("_MicrotaskMirrorQueue");
    PropagateIfError(microtask_mirror_queue_type_name);
 
    Dart_Handle microtask_mirror_queue_type =
        Dart_GetNonNullableType(async_library, microtask_mirror_queue_type_name,
                                /*number_of_type_arguments=*/0,
                                /*type_arguments=*/nullptr);
    PropagateIfError(microtask_mirror_queue_type);
 
    Dart_Handle should_profile_microtasks_field_name =
        Dart_NewStringFromCString("_shouldProfileMicrotasks");
    PropagateIfError(should_profile_microtasks_field_name);
 
    Dart_Handle set_field_result =
        Dart_SetField(microtask_mirror_queue_type,
                      should_profile_microtasks_field_name, Dart_True());
    PropagateIfError(set_field_result);
  }
#endif  // !FLUTTER_RELEASE
}

References InvokeFunction(), and PropagateIfError().

Referenced by flutter::DartRuntimeHooks::Install().

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);
}

References PropagateIfError().

Referenced by flutter::DartRuntimeHooks::Install().

InitDartFFIForIsolateGroup()

static void flutter::InitDartFFIForIsolateGroup ( )

static

Definition at line 1256 of file dart_isolate.cc.

                                         {
  NativeAssetsApi native_assets;
  memset(&native_assets, 0, sizeof(native_assets));
  // TODO(dacoharkes): Remove after flutter_tools stops kernel embedding.
  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;
  // TODO(dacoharkes): End todo.
  native_assets.dlsym = &dart::bin::NativeAssets::Dlsym;
  native_assets.dlopen = &NativeAssetsDlopen;
  native_assets.available_assets = &NativeAssetsAvailableAssets;
  Dart_InitializeNativeAssetsResolver(&native_assets);
};

References NativeAssetsAvailableAssets(), NativeAssetsDlopen(), and NativeAssetsDlopenRelative().

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);
}

References InvokeFunction(), and PropagateIfError().

Referenced by flutter::DartRuntimeHooks::Install().

InitDartIO()

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

static

Definition at line 129 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
}

References InvokeFunction(), and PropagateIfError().

Referenced by flutter::DartRuntimeHooks::Install().

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);
}

InvalidateApiState()

static void flutter::InvalidateApiState ( SkSurface &  skia_surface )

static

Definition at line 96 of file embedder_external_view.cc.

                                                        {
  auto recording_context = skia_surface.recordingContext();
 
  // Should never happen.
  FML_DCHECK(recording_context) << "Recording context was null.";
 
  auto direct_context = recording_context->asDirectContext();
  if (direct_context == nullptr) {
    // Can happen when using software rendering.
    // Print an error but otherwise continue in that case.
    FML_LOG(ERROR) << "Embedder asked to invalidate cached graphics API state "
                      "but Flutter is not using a graphics API.";
  } else {
    direct_context->resetContext(kAll_GrBackendState);
  }
}

References FML_DCHECK, and FML_LOG.

Referenced by flutter::EmbedderExternalView::Render().

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

References tonic::CheckAndHandleError(), tonic::DartInvokeField(), tonic::ToDart(), and TRACE_EVENT0.

Referenced by FindAndInvokeDartPluginRegistrant(), and flutter::DartIsolate::RunFromLibrary().

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);
}

References name.

Referenced by InitDartAsync(), InitDartInternal(), and InitDartIO().

InvokeMainEntrypoint()

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

static

Definition at line 882 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;
}

References args, tonic::CheckAndHandleError(), tonic::DartInvokeField(), FML_LOG, and tonic::ToDart().

Referenced by flutter::DartIsolate::RunFromLibrary().

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 40 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)});
}

References callback, tonic::DartInvoke(), and FML_DLOG.

Referenced by flutter::MultiFrameCodec::getNextFrame().

InvokePlatformMessageEmptyResponseCallback()

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

static

Definition at line 599 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

InvokePlatformMessageResponseCallback()

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

static

Definition at line 584 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));
}

References ANDROID_SHELL_HOLDER, fml::MallocMapping::Copy(), FML_DCHECK, and message.

Referenced by RegisterApi().

is_power_of_two()

static constexpr bool flutter::is_power_of_two ( int  value )

inlinestaticconstexpr

Definition at line 9 of file dl_storage.cc.

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

References value.

Referenced by flutter::DisplayListStorage::allocate().

IsAllowedDartVMFlag()

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

static

Definition at line 165 of file switches.cc.

                                                       {
  for (uint32_t i = 0; i < std::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;
}

References i, and kAllowedDartFlags.

Referenced by SettingsFromCommandLine().

IsDisplayListWorthRasterizing()

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

static

Definition at line 24 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(ToSkRect(display_list->GetBounds()))) {
    // 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);
}

References flutter::RasterCacheUtil::CanRasterizeRect(), flutter::DisplayListComplexityCalculator::Compute(), flutter::DisplayList::GetBounds(), flutter::DisplayListComplexityCalculator::ShouldBeCached(), and ToSkRect().

Referenced by flutter::DisplayListRasterCacheItem::PrerollSetup().

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

Referenced by TEST().

IsProcResolverOpenGLES()

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

static

Definition at line 57 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;
}

References FML_CHECK, and GPU_GL_VERSION.

Referenced by CreateGLInterface().

IsSurfaceControlEnabled()

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

static

Definition at line 417 of file platform_view_android_jni_impl.cc.

                                                        {
  return ANDROID_SHELL_HOLDER->IsSurfaceControlEnabled();
}

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

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);
}

References path, x, and y.

LoadDartDeferredLibrary()

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

static

Definition at line 659 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));
}

References ANDROID_SHELL_HOLDER, fml::NativeLibrary::CreateWithHandle(), flutter::DartSnapshot::kIsolateDataSymbol, flutter::DartSnapshot::kIsolateInstructionsSymbol, LoadLoadingUnitFailure(), path, and fml::jni::StringArrayToVector().

Referenced by RegisterApi().

LoadLibraryFromKernel()

EXPORTED Dart_Handle flutter::LoadLibraryFromKernel

(

const char *

path

)

Definition at line 535 of file tester_main.cc.

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

References fml::FileMapping::CreateReadOnly(), flutter::DartIsolate::LoadLibraryFromKernel(), and path.

LoadLoadingUnitFailure()

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

static

Definition at line 643 of file platform_view_android_jni_impl.cc.

                                                   {
  // TODO(garyq): Implement
}

Referenced by DeferredComponentInstallFailure(), and LoadDartDeferredLibrary().

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";
}

References _EGL_ERROR_DESC, FML_LOG, i, and name.

Referenced by flutter::AndroidContextGLSkia::AndroidContextGLSkia(), flutter::AndroidContextGLSkia::ClearCurrent(), flutter::AndroidEGLSurface::GetSize(), and flutter::AndroidEGLSurface::MakeCurrent().

LookupCallbackInformation()

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

static

Definition at line 319 of file platform_view_android_jni_impl.cc.

                                                       {
  auto cbInfo = flutter::DartCallbackCache::GetCallbackInformation(handle);
  if (cbInfo == nullptr) {
    return nullptr;
  }
  return env->NewObject(g_flutter_callback_info_class->obj(),
                        g_flutter_callback_info_constructor,
                        env->NewStringUTF(cbInfo->name.c_str()),
                        env->NewStringUTF(cbInfo->class_name.c_str()),
                        env->NewStringUTF(cbInfo->library_path.c_str()));
}

References g_flutter_callback_info_class, g_flutter_callback_info_constructor, and flutter::DartCallbackCache::GetCallbackInformation().

Referenced by RegisterApi().

LookupEntryPoint()

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

Definition at line 544 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));
}

References name.

MakeBackingStoreConfig()

static FlutterBackingStoreConfig flutter::MakeBackingStoreConfig ( int64_t  view_id, const DlISize &  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;
}

References impeller::TSize< T >::height, FlutterSize::height, FlutterBackingStoreConfig::size, FlutterBackingStoreConfig::struct_size, FlutterBackingStoreConfig::view_id, view_id, impeller::TSize< T >::width, and FlutterSize::width.

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

References flutter::PersistentCache::cache_sksl(), flutter::PersistentCache::GetCacheForProcess(), and flutter::PersistentCache::MarkStrategySet().

Referenced by flutter::ShellIOManager::CreateCompatibleResourceLoadingContext(), flutter::GPUSurfaceGLSkia::MakeGLContext(), flutter::testing::TEST(), flutter_runner::testing::TEST_F(), and flutter::testing::TestVulkanContext::TestVulkanContext().

MakeThreadConfig()

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

Definition at line 128 of file embedder_thread_host.cc.

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

References kFlutterThreadName, flutter::ThreadHost::ThreadHostConfig::MakeThreadName(), and type.

MarkTextureFrameAvailable()

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

static

Definition at line 572 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER, and texture_id.

Referenced by RegisterApi().

MoveTo()

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

Definition at line 18 of file path_ops.cc.

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

References path, x, and 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);
}

NativeAssetsAvailableAssets()

static char * flutter::NativeAssetsAvailableAssets ( )

static

Definition at line 1245 of file dart_isolate.cc.

                                           {
  auto* isolate_group_data =
      static_cast<std::shared_ptr<DartIsolateGroupData>*>(
          Dart_CurrentIsolateGroupData());
  auto native_assets_manager = (*isolate_group_data)->GetNativeAssetsManager();
  FML_DCHECK(native_assets_manager != nullptr);
  auto available_assets = native_assets_manager->AvailableNativeAssets();
  auto* result = fml::strdup(available_assets.c_str());
  return result;
}

References FML_DCHECK, and fml::strdup().

Referenced by InitDartFFIForIsolateGroup().

NativeAssetsDlopen()

static void * flutter::NativeAssetsDlopen ( const char *  asset_id, char **  error  )

static

Definition at line 1202 of file dart_isolate.cc.

                                                                    {
  auto* isolate_group_data =
      static_cast<std::shared_ptr<DartIsolateGroupData>*>(
          Dart_CurrentIsolateGroupData());
  auto native_assets_manager = (*isolate_group_data)->GetNativeAssetsManager();
  if (native_assets_manager == nullptr) {
    return nullptr;
  }
 
  std::vector<std::string> asset_path =
      native_assets_manager->LookupNativeAsset(asset_id);
  if (asset_path.size() == 0) {
    // The asset id was not in the mapping.
    return nullptr;
  }
 
  auto& path_type = asset_path[0];
  std::string path;
  static constexpr const char* kAbsolute = "absolute";
  static constexpr const char* kExecutable = "executable";
  static constexpr const char* kProcess = "process";
  static constexpr const char* kRelative = "relative";
  static constexpr const char* kSystem = "system";
  if (path_type == kAbsolute || path_type == kRelative ||
      path_type == kSystem) {
    path = asset_path[1];
  }
 
  if (path_type == kAbsolute) {
    return dart::bin::NativeAssets::DlopenAbsolute(path.c_str(), error);
  } else if (path_type == kRelative) {
    return NativeAssetsDlopenRelative(path.c_str(), error);
  } else if (path_type == kSystem) {
    return dart::bin::NativeAssets::DlopenSystem(path.c_str(), error);
  } else if (path_type == kProcess) {
    return dart::bin::NativeAssets::DlopenProcess(error);
  } else if (path_type == kExecutable) {
    return dart::bin::NativeAssets::DlopenExecutable(error);
  }
 
  return nullptr;
}

References error, NativeAssetsDlopenRelative(), and path.

Referenced by InitDartFFIForIsolateGroup().

NativeAssetsDlopenRelative()

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

static

Definition at line 1193 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);
}

References error, and path.

Referenced by InitDartFFIForIsolateGroup(), and NativeAssetsDlopen().

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);
}

References extended.

NotEquals() [1/9]

template<class T , class U >

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

Definition at line 96 of file dl_comparable.h.

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

References Equals().

NotEquals() [2/9]

template<class T , class U >

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

Definition at line 107 of file dl_comparable.h.

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

References Equals().

NotEquals() [3/9]

template<class T , class U >

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

Definition at line 76 of file dl_comparable.h.

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

References Equals().

NotEquals() [4/9]

template<class T , class U >

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

Definition at line 102 of file dl_comparable.h.

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

References Equals().

NotEquals() [5/9]

template<class T , class U >

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

Definition at line 112 of file dl_comparable.h.

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

References Equals().

NotEquals() [6/9]

template<class T , class U >

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

Definition at line 81 of file dl_comparable.h.

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

References Equals().

NotEquals() [7/9]

template<class T , class U >

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

Definition at line 86 of file dl_comparable.h.

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

References Equals().

NotEquals() [8/9]

template<class T , class U >

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

Definition at line 91 of file dl_comparable.h.

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

References Equals().

NotEquals() [9/9]

template<class T , class U >

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

Definition at line 71 of file dl_comparable.h.

                                       {
  return !Equals(a, b);
}

References Equals().

Referenced by flutter::BackdropFilterLayer::Diff(), flutter::ColorFilterLayer::Diff(), flutter::ImageFilterLayer::Diff(), flutter::testing::TestParameters::should_match(), flutter::testing::testEquals(), flutter::testing::testEquals(), flutter::testing::testEquals(), flutter::testing::testNotEquals(), flutter::testing::testNotEquals(), flutter::testing::testNotEquals(), and flutter::testing::TestNotEquals().

NotifyLowMemoryWarning()

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

static

Definition at line 607 of file platform_view_android_jni_impl.cc.

                                                       {
  ANDROID_SHELL_HOLDER->NotifyLowMemoryWarning();
}

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

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

References TRUE.

Referenced by flutter::WindowsLifecycleManager::IsLastWindowOfProcess().

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);
}

References Op().

Referenced by flutter::CanvasPath::op(), and Op().

operator<<()

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

Definition at line 112 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] "
     << "View Constraints: [" << a.physical_min_width_constraint << "-"
     << a.physical_max_width_constraint << "W "
     << a.physical_min_height_constraint << "-"
     << a.physical_max_height_constraint << "H] "
     << "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;
}

References flutter::ViewportMetrics::device_pixel_ratio, flutter::ViewportMetrics::display_id, flutter::ViewportMetrics::physical_display_features_type, flutter::ViewportMetrics::physical_height, flutter::ViewportMetrics::physical_max_height_constraint, flutter::ViewportMetrics::physical_max_width_constraint, flutter::ViewportMetrics::physical_min_height_constraint, flutter::ViewportMetrics::physical_min_width_constraint, flutter::ViewportMetrics::physical_padding_bottom, flutter::ViewportMetrics::physical_padding_left, flutter::ViewportMetrics::physical_padding_right, flutter::ViewportMetrics::physical_padding_top, flutter::ViewportMetrics::physical_system_gesture_inset_bottom, flutter::ViewportMetrics::physical_system_gesture_inset_left, flutter::ViewportMetrics::physical_system_gesture_inset_right, flutter::ViewportMetrics::physical_system_gesture_inset_top, flutter::ViewportMetrics::physical_view_inset_bottom, flutter::ViewportMetrics::physical_view_inset_left, flutter::ViewportMetrics::physical_view_inset_right, flutter::ViewportMetrics::physical_view_inset_top, and flutter::ViewportMetrics::physical_width.

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

References flutter::LayoutGoal::keyChar, flutter::LayoutGoal::keyCode, and flutter::LayoutGoal::mandatory.

operator==() [2/2]

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

Definition at line 79 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_min_width_constraint == b.physical_min_width_constraint &&
         a.physical_max_width_constraint == b.physical_max_width_constraint &&
         a.physical_min_height_constraint == b.physical_min_height_constraint &&
         a.physical_max_height_constraint == b.physical_max_height_constraint &&
         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;
}

References flutter::ViewportMetrics::device_pixel_ratio, flutter::ViewportMetrics::display_id, flutter::ViewportMetrics::physical_display_features_bounds, flutter::ViewportMetrics::physical_display_features_state, flutter::ViewportMetrics::physical_display_features_type, flutter::ViewportMetrics::physical_height, flutter::ViewportMetrics::physical_max_height_constraint, flutter::ViewportMetrics::physical_max_width_constraint, flutter::ViewportMetrics::physical_min_height_constraint, flutter::ViewportMetrics::physical_min_width_constraint, flutter::ViewportMetrics::physical_padding_bottom, flutter::ViewportMetrics::physical_padding_left, flutter::ViewportMetrics::physical_padding_right, flutter::ViewportMetrics::physical_padding_top, flutter::ViewportMetrics::physical_system_gesture_inset_bottom, flutter::ViewportMetrics::physical_system_gesture_inset_left, flutter::ViewportMetrics::physical_system_gesture_inset_right, flutter::ViewportMetrics::physical_system_gesture_inset_top, flutter::ViewportMetrics::physical_touch_slop, flutter::ViewportMetrics::physical_view_inset_bottom, flutter::ViewportMetrics::physical_view_inset_left, flutter::ViewportMetrics::physical_view_inset_right, flutter::ViewportMetrics::physical_view_inset_top, and flutter::ViewportMetrics::physical_width.

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());
}

References fml::Base32Decode(), FML_LOG, input(), and ParseBase32().

Referenced by flutter::PersistentCache::LoadSkSLs(), and ParseBase32().

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: " << static_cast<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: " << static_cast<int>(error);
    FML_LOG(ERROR) << "Base64 can't decode: " << input;
    return nullptr;
  }
 
  return data;
}

References data, error, FML_LOG, input(), and ParseBase64().

Referenced by flutter::PersistentCache::LoadSkSLs(), and ParseBase64().

ParseCommaDelimited()

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

static

Definition at line 155 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;
}

References input().

Referenced by SettingsFromCommandLine().

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

References FML_DCHECK.

Referenced by flutter::IsolateConfiguration::InferFromSettings().

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

References flutter::LanguageInfo::language, flutter::LanguageInfo::region, flutter::LanguageInfo::script, size, and fml::WideStringToUtf8().

Referenced by GetPreferredLanguageInfo(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

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));
  }
}

References FML_LOG, key, fml::MakeCopyable(), TRACE_EVENT0, value, and fml::WriteAtomically().

Referenced by flutter::PersistentCache::DumpSkp().

platforms()

it will be possible to load the file into Perfetto s trace viewer use test 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 flutter::platforms

(

See https:"This option is only available on the desktop test shells."

)

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

Referenced by flutter::SettingsPlugin::GetAlwaysUse24HourFormat(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

PrefetchDefaultFontManager()

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

static

Definition at line 238 of file flutter_main.cc.

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

References txt::GetDefaultFontManager(), and PrefetchDefaultFontManager().

Referenced by PrefetchDefaultFontManager(), and flutter::FlutterMain::Register().

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

References FML_DCHECK, and fml::MakeCopyable().

Referenced by flutter::IsolateConfiguration::InferFromSettings().

PrintUsage()

void flutter::PrintUsage

(

const std::string &

executable_name

)

Definition at line 89 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 << "Flutter Content Hash: " << GetFlutterContentHash() << 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;
}

References GetDartVersion(), GetFlutterContentHash(), GetFlutterEngineVersion(), GetSkiaVersion(), and i.

Referenced by main().

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

References CF_PROPERTY_LIST_IMMUTABLE, fml::FileMapping::CreateReadOnly(), and FML_DLOG.

Referenced by TEST().

ProfilingFlags()

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

static

Definition at line 180 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) {
    std::vector<const char*> flags = {
        // 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
    };
 
    if (profile_startup) {
      // This instructs the profiler to discard new samples once the profiler
      // sample buffer is full. When this flag is not set, the profiler sample
      // buffer is used as a ring buffer, meaning that once it is full, new
      // samples start overwriting the oldest ones."
      flags.push_back("--profile_startup");
    }
 
    return flags;
  } 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);
  }
}

References FML_LOG.

Referenced by flutter::DartRuntimeHooks::GetCallbackFromHandle(), GetFunctionClassName(), GetFunctionLibraryUrl(), GetFunctionName(), InitDartAsync(), InitDartCore(), InitDartInternal(), and InitDartIO().

ProtectEmpty() [1/2]

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

static

Definition at line 124 of file dl_builder.cc.

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

References impeller::TRect< T >::IsEmpty(), and kEmpty.

ProtectEmpty() [2/2]

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

static

Definition at line 15 of file dl_matrix_clip_tracker.cc.

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

References impeller::TRect< T >::IsEmpty(), and kEmpty.

PushBackAll()

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

Definition at line 227 of file dart_vm.cc.

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

References args, argv, and 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());
  }
}

Referenced by flutter::SemanticsUpdateBuilder::updateNode().

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

References flutter::PaintContext::dst_color_space, FML_DCHECK, flutter::PaintContext::gr_context, flutter::RasterCacheItem::kChildren, flutter::RasterCacheItem::kCurrent, flutter::RasterCacheItem::kNone, flutter::Layer::needs_painting(), flutter::Layer::Paint(), flutter::Layer::PaintChildren(), flutter::PaintContext::raster_time, flutter::LayerStateStack::set_delegate(), flutter::PaintContext::state_stack, flutter::PaintContext::texture_registry, flutter::PaintContext::ui_time, and flutter::PaintContext::view_embedder.

Referenced by flutter::LayerRasterCacheItem::TryToPrepareRasterCache().

RectHeight()

LONG flutter::RectHeight

(

const RECT &

r

)

Definition at line 15 of file rect_helper.h.

                               {
  return r.bottom - r.top;
}

Referenced by flutter::HostWindow::SetFullscreen().

RectWidth()

LONG flutter::RectWidth

(

const RECT &

r

)

Definition at line 11 of file rect_helper.h.

                              {
  return r.right - r.left;
}

Referenced by flutter::HostWindow::SetFullscreen().

RegisterApi()

bool flutter::RegisterApi

(

JNIEnv *

env

)

Definition at line 713 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;J)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;J)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;Z)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),
      },
      {
          .name = "nativeIsSurfaceControlEnabled",
          .signature = "(J)Z",
          .fnPtr = reinterpret_cast<void*>(&IsSurfaceControlEnabled),
      }};
 
  if (env->RegisterNatives(g_flutter_jni_class->obj(), flutter_jni_methods,
                           std::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;
  }
 
  FLUTTER_FOR_EACH_JNI_METHOD(FLUTTER_BIND_JNI)
 
  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;
}

References AttachJNI(), CleanupMessageData(), DeferredComponentInstallFailure(), DestroyJNI(), DispatchEmptyPlatformMessage(), DispatchPlatformMessage(), DispatchPointerDataPacket(), DispatchSemanticsAction(), FLUTTER_BIND_JNI, FLUTTER_FOR_EACH_JNI_METHOD, FlutterTextUtilsIsEmoji(), FlutterTextUtilsIsEmojiModifier(), FlutterTextUtilsIsEmojiModifierBase(), FlutterTextUtilsIsRegionalIndicator(), FlutterTextUtilsIsVariationSelector(), FML_LOG, g_bitmap_class, g_bitmap_config_class, g_bitmap_config_value_of, g_bitmap_copy_pixels_from_buffer_method, g_bitmap_create_bitmap_method, g_flutter_jni_class, g_java_long_class, g_jni_constructor, g_jni_shell_holder_field, g_long_constructor, g_overlay_surface_id_method, g_overlay_surface_surface_method, GetBitmap(), GetIsSoftwareRendering(), InvokePlatformMessageEmptyResponseCallback(), InvokePlatformMessageResponseCallback(), IsSurfaceControlEnabled(), LoadDartDeferredLibrary(), LookupCallbackInformation(), MarkTextureFrameAvailable(), NotifyLowMemoryWarning(), fml::jni::JavaRef< T >::obj(), RegisterImageTexture(), RegisterTexture(), RunBundleAndSnapshotFromLibrary(), ScheduleFrame(), SetAccessibilityFeatures(), SetSemanticsEnabled(), SetViewportMetrics(), SpawnJNI(), SurfaceChanged(), SurfaceCreated(), SurfaceDestroyed(), SurfaceWindowChanged(), UnregisterTexture(), UpdateDisplayMetrics(), and UpdateJavaAssetManager().

Referenced by flutter::PlatformViewAndroid::Register().

RegisterImageTexture()

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

static

Definition at line 547 of file platform_view_android_jni_impl.cc.

                                                               {
  ImageExternalTexture::ImageLifecycle lifecycle =
      reset_on_background ? ImageExternalTexture::ImageLifecycle::kReset
                          : ImageExternalTexture::ImageLifecycle::kKeepAlive;
 
  ANDROID_SHELL_HOLDER->GetPlatformView()->RegisterImageTexture(
      static_cast<int64_t>(texture_id),                                  //
      fml::jni::ScopedJavaGlobalRef<jobject>(env, image_texture_entry),  //
      lifecycle                                                          //
  );
}

References ANDROID_SHELL_HOLDER, flutter::ImageExternalTexture::kKeepAlive, flutter::ImageExternalTexture::kReset, and texture_id.

Referenced by RegisterApi().

RegisterTexture()

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

static

Definition at line 536 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)  //
  );
}

References ANDROID_SHELL_HOLDER, and texture_id.

Referenced by RegisterApi().

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 866 of file rasterizer.cc.

                                                            {
  // There is no root surface transformation for the screenshot layer. Reset
  // the matrix to identity.
  DlMatrix root_surface_transformation;
 
  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();
}

References flutter::CompositorContext::AcquireFrame(), flutter::DlCanvas::Clear(), flutter::DlCanvas::Flush(), and RenderFrameForScreenshot().

Referenced by RenderFrameForScreenshot().

Reset()

API void flutter::Reset

(

SkPath *

path

)

Definition at line 40 of file path_ops.cc.

                         {
  path->reset();
}

References path.

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(nullptr);
  }
 
  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;
}

References FML_DCHECK, FML_LOG, image, fml::tracing::TraceFlow::Step(), and TRACE_EVENT0.

Referenced by flutter::ImageDecoderSkia::ImageFromCompressedData(), and ImageFromDecompressedData().

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_paths,   // native_library_paths
      DartSnapshot::kIsolateDataSymbol,     // native_library_symbol_name
      false                                 // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

References flutter::Settings::application_library_paths, flutter::Settings::isolate_snapshot_data, flutter::Settings::isolate_snapshot_data_path, kDartIsolateSnapshotData, flutter::DartSnapshot::kIsolateDataSymbol, and SearchMapping().

Referenced by flutter::DartSnapshot::IsolateSnapshotFromSettings().

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_paths,        // native_library_paths
      DartSnapshot::kIsolateInstructionsSymbol,  // native_library_symbol_name
      true                                       // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

References flutter::Settings::application_library_paths, flutter::Settings::isolate_snapshot_instr, flutter::Settings::isolate_snapshot_instr_path, kDartIsolateSnapshotInstructions, flutter::DartSnapshot::kIsolateInstructionsSymbol, and SearchMapping().

Referenced by flutter::DartSnapshot::IsolateSnapshotFromSettings().

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_paths,  // native_library_paths
      DartSnapshot::kVMDataSymbol,         // native_library_symbol_name
      false                                // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

References flutter::Settings::application_library_paths, kDartVmSnapshotData, flutter::DartSnapshot::kVMDataSymbol, SearchMapping(), flutter::Settings::vm_snapshot_data, and flutter::Settings::vm_snapshot_data_path.

Referenced by flutter::DartSnapshot::VMSnapshotFromSettings().

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_paths,   // native_library_paths
      DartSnapshot::kVMInstructionsSymbol,  // native_library_symbol_name
      true                                  // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

References flutter::Settings::application_library_paths, kDartVmSnapshotInstructions, flutter::DartSnapshot::kVMInstructionsSymbol, SearchMapping(), flutter::Settings::vm_snapshot_instr, and flutter::Settings::vm_snapshot_instr_path.

Referenced by flutter::DartSnapshot::VMSnapshotFromSettings().

RunBundleAndSnapshotFromLibrary()

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

static

Definition at line 297 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, engineId);
}

References ANDROID_SHELL_HOLDER, fml::jni::JavaStringToString(), and fml::jni::StringListToVector().

Referenced by RegisterApi().

RunTester()

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

Definition at line 344 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
      ui_task_runner,        // runner for Dart microtasks
      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();
}

References fml::paths::AbsolutePath(), fml::MessageLoop::AddTaskObserver(), flutter::Settings::application_kernel_asset, flutter::Settings::assets_dir, flutter::Settings::assets_path, ConfigureShell(), fml::MallocMapping::Copy(), flutter::Shell::Create(), flutter::IsolateConfiguration::CreateForKernel(), flutter::ScriptCompletionTaskObserver::DidProcessTask(), fml::Duplicate(), flutter::Settings::enable_impeller, flutter::Settings::enable_vulkan_validation, fml::MessageLoop::EnsureInitializedForCurrentThread(), flutter::Engine::Failure, FML_LOG, g_shell, fml::MessageLoop::GetCurrent(), flutter::ScriptCompletionTaskObserver::GetExitCodeForLastError(), flutter::Shell::GetPlatformView(), fml::MessageLoop::GetTaskRunner(), flutter::Shell::GetTaskRunners(), flutter::Shell::IsSetup(), flutter::Rasterizer::kBitmap, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, fml::kRead, fml::FileMapping::kRead, flutter::ThreadHost::kUi, fml::MakeCopyable(), fml::OpenDirectory(), fml::OpenFile(), fml::MessageLoop::RemoveTaskObserver(), fml::MessageLoop::Run(), flutter::Shell::RunEngine(), fml::TaskRunner::RunNowOrPostTask(), fml::AutoResetWaitableEvent::Signal(), UnblockSIGPROF(), and fml::AutoResetWaitableEvent::Wait().

Referenced by main().

RuntimeStageBackendToString()

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

static

Definition at line 30 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";
    case impeller::RuntimeStageBackend::kOpenGLES3:
      return "OpenGLES3";
  }
}

References impeller::kMetal, impeller::kOpenGLES, impeller::kOpenGLES3, impeller::kSkSL, and impeller::kVulkan.

Referenced by flutter::FragmentProgram::initFromAsset().

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());
  }
}

References value.

Referenced by flutter::CanvasPath::addArc(), flutter::CanvasPath::addOval(), flutter::CanvasPath::addPath(), flutter::CanvasPath::addPathWithMatrix(), flutter::SceneBuilder::addPerformanceOverlay(), flutter::SceneBuilder::addPicture(), flutter::SceneBuilder::addPlatformView(), flutter::CanvasPath::addRect(), flutter::SceneBuilder::addTexture(), flutter::CanvasPath::arcTo(), flutter::CanvasPath::arcToPoint(), flutter::CanvasPath::conicTo(), flutter::CanvasPath::contains(), flutter::RSuperellipse::contains(), flutter::RSuperellipse::Create(), flutter::CanvasPath::cubicTo(), flutter::CanvasPath::extendWithPath(), flutter::CanvasPath::extendWithPathAndMatrix(), flutter::CanvasPathMeasure::getPosTan(), flutter::CanvasPathMeasure::getSegment(), flutter::ImageFilter::initBlur(), flutter::ImageFilter::initDilate(), flutter::ImageFilter::initErode(), flutter::CanvasGradient::initRadial(), flutter::CanvasGradient::initSweep(), flutter::CanvasGradient::initTwoPointConical(), flutter::CanvasPath::lineTo(), flutter::CanvasPath::moveTo(), flutter::SceneBuilder::pushClipRect(), flutter::SceneBuilder::pushImageFilter(), flutter::SceneBuilder::pushOffset(), flutter::SceneBuilder::pushOpacity(), flutter::SceneBuilder::pushShaderMask(), flutter::CanvasPath::quadraticBezierTo(), flutter::CanvasPath::relativeArcToPoint(), flutter::CanvasPath::relativeConicTo(), flutter::CanvasPath::relativeCubicTo(), flutter::CanvasPath::relativeLineTo(), flutter::CanvasPath::relativeMoveTo(), flutter::CanvasPath::relativeQuadraticBezierTo(), flutter::CanvasPath::shift(), ToDlMatrix(), ToSkM44(), ToSkMatrix(), and flutter::SemanticsUpdateBuilder::updateNode().

ScheduleFrame()

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

static

Definition at line 580 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi(), flutter::testing::TEST(), and flutter::testing::TEST_F().

ScreenshotLayerTreeAsPicture()

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

static

Definition at line 829 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));
 
  DlMatrix root_surface_transformation;
  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
}

References flutter::CompositorContext::AcquireFrame(), FML_DCHECK, flutter::LayerTree::frame_size(), impeller::TSize< T >::height, ScreenshotLayerTreeAsPicture(), SerializeImageWithoutData(), SerializeTypefaceWithData(), SerializeTypefaceWithoutData(), and impeller::TSize< T >::width.

Referenced by flutter::Rasterizer::ScreenshotLastLayerTree(), and ScreenshotLayerTreeAsPicture().

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_paths, 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_paths) {
    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;
}

References fml::NativeLibrary::Create(), fml::NativeLibrary::CreateForCurrentProcess(), GetFileMapping(), and path.

Referenced by ResolveIsolateData(), ResolveIsolateInstructions(), ResolveVMData(), ResolveVMInstructions(), and flutter::DartSnapshot::VMServiceIsolateSnapshotFromSettings().

SemanticsFlagsToInt()

FlutterSemanticsFlag flutter::SemanticsFlagsToInt

(

const SemanticsFlags &

flags

)

Definition at line 89 of file embedder_semantics_update.cc.

                                                                      {
  int result = 0;
 
  if (flags.isChecked != SemanticsCheckState::kNone) {
    result |= (1 << 0);
  }
  if (flags.isChecked == SemanticsCheckState::kTrue) {
    result |= (1 << 1);
  }
  if (flags.isSelected == SemanticsTristate::kTrue) {
    result |= (1 << 2);
  }
  if (flags.isButton) {
    result |= (1 << 3);
  }
  if (flags.isTextField) {
    result |= (1 << 4);
  }
  if (flags.isFocused == SemanticsTristate::kTrue) {
    result |= (1 << 5);
  }
  if (flags.isEnabled != SemanticsTristate::kNone) {
    result |= (1 << 6);
  }
  if (flags.isEnabled == SemanticsTristate::kTrue) {
    result |= (1 << 7);
  }
  if (flags.isInMutuallyExclusiveGroup) {
    result |= (1 << 8);
  }
  if (flags.isHeader) {
    result |= (1 << 9);
  }
  if (flags.isObscured) {
    result |= (1 << 10);
  }
  if (flags.scopesRoute) {
    result |= (1 << 11);
  }
  if (flags.namesRoute) {
    result |= (1 << 12);
  }
  if (flags.isHidden) {
    result |= (1 << 13);
  }
  if (flags.isImage) {
    result |= (1 << 14);
  }
  if (flags.isLiveRegion) {
    result |= (1 << 15);
  }
  if (flags.isToggled != SemanticsTristate::kNone) {
    result |= (1 << 16);
  }
  if (flags.isToggled == SemanticsTristate::kTrue) {
    result |= (1 << 17);
  }
  if (flags.hasImplicitScrolling) {
    result |= (1 << 18);
  }
  if (flags.isMultiline) {
    result |= (1 << 19);
  }
  if (flags.isReadOnly) {
    result |= (1 << 20);
  }
  if (flags.isFocused != SemanticsTristate::kNone) {
    result |= (1 << 21);
  }
  if (flags.isLink) {
    result |= (1 << 22);
  }
  if (flags.isSlider) {
    result |= (1 << 23);
  }
  if (flags.isKeyboardKey) {
    result |= (1 << 24);
  }
  if (flags.isChecked == SemanticsCheckState::kMixed) {
    result |= (1 << 25);
  }
  if (flags.isExpanded != SemanticsTristate::kNone) {
    result |= (1 << 26);
  }
  if (flags.isExpanded == SemanticsTristate::kTrue) {
    result |= (1 << 27);
  }
  if (flags.isSelected != SemanticsTristate::kNone) {
    result |= (1 << 28);
  }
  if (flags.isRequired != SemanticsTristate::kNone) {
    result |= (1 << 29);
  }
  if (flags.isRequired == SemanticsTristate::kTrue) {
    result |= (1 << 30);
  }
 
  return static_cast<FlutterSemanticsFlag>(result);
}

References flutter::SemanticsFlags::hasImplicitScrolling, flutter::SemanticsFlags::isButton, flutter::SemanticsFlags::isChecked, flutter::SemanticsFlags::isEnabled, flutter::SemanticsFlags::isExpanded, flutter::SemanticsFlags::isFocused, flutter::SemanticsFlags::isHeader, flutter::SemanticsFlags::isHidden, flutter::SemanticsFlags::isImage, flutter::SemanticsFlags::isInMutuallyExclusiveGroup, flutter::SemanticsFlags::isKeyboardKey, flutter::SemanticsFlags::isLink, flutter::SemanticsFlags::isLiveRegion, flutter::SemanticsFlags::isMultiline, flutter::SemanticsFlags::isObscured, flutter::SemanticsFlags::isReadOnly, flutter::SemanticsFlags::isRequired, flutter::SemanticsFlags::isSelected, flutter::SemanticsFlags::isSlider, flutter::SemanticsFlags::isTextField, flutter::SemanticsFlags::isToggled, kMixed, kNone, kTrue, flutter::SemanticsFlags::namesRoute, and flutter::SemanticsFlags::scopesRoute.

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();
};

References FML_CHECK, image, and flutter::ImageMetaData::width.

Referenced by ScreenshotLayerTreeAsPicture().

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);
}

Referenced by ScreenshotLayerTreeAsPicture().

SerializeTypefaceWithoutData()

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

Definition at line 14 of file serialization_callbacks.cc.

                                                                            {
  return SkData::MakeEmpty();
}

Referenced by ScreenshotLayerTreeAsPicture().

ServiceProtocolFailureError()

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

static

Definition at line 1874 of file shell.cc.

  {
    rapidjson::Value details(rapidjson::kObjectType);
    details.AddMember("details", std::move(error_details), allocator);
    response->AddMember("data", details, allocator);
  }
}

ServiceProtocolParameterError()

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

static

Definition at line 1860 of file shell.cc.

         {
      weak_engine_->GetUIIsolateMainPort(),
      weak_engine_->GetUIIsolateName(),
  };
}
 
static void ServiceProtocolParameterError(rapidjson::Document* response,
                                          std::string error_details) {
  auto& allocator = response->GetAllocator();
  response->SetObject();

ServiceStreamCancelCallback()

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

static

Definition at line 168 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);
  }
}

References kStderrStreamId, and kStdoutStreamId.

ServiceStreamListenCallback()

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

static

Definition at line 157 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;
}

References kStderrStreamId, and kStdoutStreamId.

SetAccessibilityFeatures()

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

static

Definition at line 525 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

SetFontFile()

void flutter::SetFontFile

(

const std::string &

file

)

Definition at line 24 of file flow_test_utils.cc.

                                        {
  gFontFile = file;
}

References gFontFile.

Referenced by main().

SetGoldenDir()

void flutter::SetGoldenDir

(

const std::string &

dir

)

Definition at line 16 of file flow_test_utils.cc.

                                        {
  gGoldenDir = dir;
}

References gGoldenDir.

Referenced by main().

SetSemanticsEnabled()

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

static

Definition at line 518 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

SetTextureLayout()

static bool flutter::SetTextureLayout ( const ContextVK &  context, const TextureSourceVK *  texture, vk::ImageLayout  layout, LayoutUpdateMode  mode  )

static

Definition at line 44 of file surface_texture_external_texture_vk_impeller.cc.

                                                    {
  TRACE_EVENT0("flutter", __FUNCTION__);
  if (!texture) {
    return true;
  }
  auto command_buffer = context.CreateCommandBuffer();
  if (!command_buffer) {
    VALIDATION_LOG
        << "Could not create command buffer for texture layout update.";
    return false;
  }
  command_buffer->SetLabel("GLVKTextureLayoutUpdateCB");
  const CommandBufferVK& encoder = CommandBufferVK::Cast(*command_buffer);
  const auto command_buffer_vk = encoder.GetCommandBuffer();
 
  BarrierVK barrier;
  barrier.cmd_buffer = command_buffer_vk;
  barrier.new_layout = layout;
  barrier.src_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput |
                      impeller::vk::PipelineStageFlagBits::eFragmentShader;
  barrier.src_access = vk::AccessFlagBits::eColorAttachmentWrite |
                       vk::AccessFlagBits::eShaderRead;
  barrier.dst_stage = impeller::vk::PipelineStageFlagBits::eFragmentShader;
  barrier.dst_access = vk::AccessFlagBits::eShaderRead;
 
  if (!texture->SetLayout(barrier).ok()) {
    VALIDATION_LOG << "Could not encoder layout transition.";
    return false;
  }
 
  encoder.EndCommandBuffer();
 
  vk::SubmitInfo submit_info;
  submit_info.setCommandBuffers(command_buffer_vk);
 
  // There is no need to track the fence in the encoder since we are going to do
  // a sync wait for completion.
  vk::UniqueFence fence;
 
  if (mode == LayoutUpdateMode::kSync) {
    auto fence_pair =
        context.GetDevice().createFenceUnique(vk::FenceCreateFlags{});
    if (fence_pair.result != impeller::vk::Result::eSuccess) {
      VALIDATION_LOG << "Could not create fence.";
      return false;
    }
    fence = std::move(fence_pair.value);
  }
 
  if (context.GetGraphicsQueue()->Submit(submit_info, fence.get()) !=
      impeller::vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not submit layout transition fence.";
    return false;
  }
 
  using namespace std::chrono_literals;
 
  if (fence &&
      context.GetDevice().waitForFences(
          fence.get(),                                                      //
          VK_TRUE,                                                          //
          std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count()  //
          ) != impeller::vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not perform sync wait on fence.";
    return false;
  }
 
  return true;
}

References impeller::BarrierVK::cmd_buffer, impeller::ContextVK::CreateCommandBuffer(), impeller::BarrierVK::dst_access, impeller::BarrierVK::dst_stage, impeller::CommandBufferVK::EndCommandBuffer(), impeller::CommandBufferVK::GetCommandBuffer(), impeller::ContextVK::GetDevice(), impeller::ContextVK::GetGraphicsQueue(), kSync, mode, impeller::BarrierVK::new_layout, impeller::BarrierVK::src_access, impeller::BarrierVK::src_stage, texture, TRACE_EVENT0, and VALIDATION_LOG.

SettingsFromCommandLine()

Settings flutter::SettingsFromCommandLine	(	const fml::CommandLine &	command_line,
		bool	require_merged_platform_ui_thread
	)

Definition at line 230 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));
 
  // Enable mDNS VM Service Publication
  settings.enable_vm_service_publication = !command_line.HasOption(
      FlagForSwitch(Switch::DisableVMServicePublication));
 
  // Set VM Service Host
  if (command_line.HasOption(FlagForSwitch(Switch::DeviceVMServiceHost))) {
    command_line.GetOptionValue(FlagForSwitch(Switch::DeviceVMServiceHost),
                                &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;
    }
  }
 
  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.profile_startup =
      command_line.HasOption(FlagForSwitch(Switch::ProfileStartup));
 
  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.profile_microtasks =
      command_line.HasOption(FlagForSwitch(Switch::ProfileMicrotasks));
 
  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_paths.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));
 
#if FML_OS_IOS || FML_OS_IOS_SIMULATOR || SLIMPELLER
// On these configurations, the Impeller flags are completely ignored with the
// default taking hold.
#else   // FML_OS_IOS && !FML_OS_IOS_SIMULATOR
  {
    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;
    }
  }
#endif  // FML_OS_IOS && !FML_OS_IOS_SIMULATOR
 
  {
    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));
 
  settings.enable_surface_control = command_line.HasOption(
      FlagForSwitch(Switch::EnableAndroidSurfaceControl));
 
  constexpr std::string_view kMergedThreadEnabled = "enabled";
  constexpr std::string_view kMergedThreadDisabled = "disabled";
  constexpr std::string_view kMergedThreadMergeAfterLaunch = "mergeAfterLaunch";
  if (command_line.HasOption(
          FlagForSwitch(Switch::DisableMergedPlatformUIThread))) {
    FML_CHECK(!require_merged_platform_ui_thread)
        << "This platform does not support the "
        << FlagForSwitch(Switch::DisableMergedPlatformUIThread) << " flag";
 
    settings.merged_platform_ui_thread =
        Settings::MergedPlatformUIThread::kDisabled;
  } else if (command_line.HasOption(
                 FlagForSwitch(Switch::MergedPlatformUIThread))) {
    std::string merged_platform_ui;
    command_line.GetOptionValue(FlagForSwitch(Switch::MergedPlatformUIThread),
                                &merged_platform_ui);
    if (merged_platform_ui == kMergedThreadEnabled) {
      settings.merged_platform_ui_thread =
          Settings::MergedPlatformUIThread::kEnabled;
    } else if (merged_platform_ui == kMergedThreadDisabled) {
      FML_CHECK(!require_merged_platform_ui_thread)
          << "This platform does not support the "
          << FlagForSwitch(Switch::MergedPlatformUIThread) << "="
          << kMergedThreadDisabled << " flag";
 
      settings.merged_platform_ui_thread =
          Settings::MergedPlatformUIThread::kDisabled;
    } else if (merged_platform_ui == kMergedThreadMergeAfterLaunch) {
      settings.merged_platform_ui_thread =
          Settings::MergedPlatformUIThread::kMergeAfterLaunch;
    }
  }
 
  settings.enable_flutter_gpu =
      command_line.HasOption(FlagForSwitch(Switch::EnableFlutterGPU));
  settings.impeller_enable_lazy_shader_mode =
      command_line.HasOption(FlagForSwitch(Switch::ImpellerLazyShaderMode));
  settings.impeller_antialiased_lines =
      command_line.HasOption(FlagForSwitch(Switch::ImpellerAntialiasLines));
 
  return settings;
}

References flutter::Settings::application_library_paths, fml::CommandLine::argv0(), flutter::Settings::assets_path, flutter::Settings::cache_sksl, flutter::Settings::dart_flags, flutter::Settings::disable_dart_asserts, flutter::Settings::disable_service_auth_codes, flutter::Settings::domain_network_policy, flutter::Settings::dump_skp_on_shader_compilation, flutter::Settings::enable_checked_mode, flutter::Settings::enable_dart_profiling, flutter::Settings::enable_embedder_api, flutter::Settings::enable_flutter_gpu, flutter::Settings::enable_impeller, flutter::Settings::enable_opengl_gpu_tracing, flutter::Settings::enable_platform_isolates, flutter::Settings::enable_serial_gc, flutter::Settings::enable_service_port_fallback, flutter::Settings::enable_software_rendering, flutter::Settings::enable_surface_control, flutter::Settings::enable_vm_service, flutter::Settings::enable_vm_service_publication, flutter::Settings::enable_vulkan_gpu_tracing, flutter::Settings::enable_vulkan_validation, flutter::Settings::endless_trace_buffer, flutter::Settings::executable_name, FlagForSwitch(), FML_CHECK, FML_LOG, fml::CommandLine::GetOptionValue(), fml::CommandLine::GetOptionValues(), fml::CommandLine::GetOptionValueWithDefault(), GetSwitchValue(), GetSymbolMapping(), fml::CommandLine::has_argv0(), fml::CommandLine::HasOption(), flutter::Settings::icu_data_path, flutter::Settings::icu_initialization_required, flutter::Settings::icu_mapper, flutter::Settings::impeller_antialiased_lines, flutter::Settings::impeller_enable_lazy_shader_mode, IsAllowedDartVMFlag(), flutter::Settings::isolate_snapshot_data_path, flutter::Settings::isolate_snapshot_instr_path, fml::paths::JoinPaths(), flutter::Settings::kDisabled, flutter::Settings::kEnabled, flutter::Settings::kMergeAfterLaunch, flutter::Settings::leak_vm, flutter::Settings::log_tag, flutter::Settings::may_insecurely_connect_to_all_domains, flutter::Settings::merged_platform_ui_thread, name, flutter::Settings::old_gen_heap_size, ParseCommaDelimited(), path, flutter::Settings::prefetched_default_font_manager, flutter::Settings::profile_microtasks, flutter::Settings::profile_startup, flutter::Settings::purge_persistent_cache, flutter::Settings::requested_rendering_backend, flutter::Settings::resource_cache_max_bytes_threshold, flutter::Settings::route, flutter::Settings::skia_deterministic_rendering_on_cpu, flutter::Settings::start_paused, flutter::Settings::temp_directory_path, flutter::Settings::trace_allowlist, flutter::Settings::trace_skia, flutter::Settings::trace_skia_allowlist, flutter::Settings::trace_startup, flutter::Settings::trace_systrace, flutter::Settings::trace_to_file, flutter::Settings::use_asset_fonts, flutter::Settings::use_test_fonts, flutter::Settings::verbose_logging, flutter::Settings::vm_service_host, flutter::Settings::vm_service_port, flutter::Settings::vm_snapshot_data_path, flutter::Settings::vm_snapshot_instr_path, and flutter::Settings::vmservice_snapshot_library_path.

Referenced by FlutterDartProject::defaultBundleIdentifier, FlutterEngineInitialize(), main(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), and flutter::testing::TestDartVmFlags().

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 333 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]);
 
  // TODO(boetger): update for https://github.com/flutter/flutter/issues/149033
  const flutter::ViewportMetrics metrics{
      static_cast<double>(devicePixelRatio),  // p_device_pixel_ratio
      static_cast<double>(physicalWidth),     // p_physical_width
      static_cast<double>(physicalHeight),    // p_physical_height
      static_cast<double>(physicalWidth),     // p_physical_min_width_constraint
      static_cast<double>(physicalWidth),     // p_physical_max_width_constraint
      static_cast<double>(physicalHeight),  // p_physical_min_height_constraint
      static_cast<double>(physicalHeight),  // p_physical_max_height_constraint
      static_cast<double>(physicalPaddingTop),     // p_physical_padding_top
      static_cast<double>(physicalPaddingRight),   // p_physical_padding_right
      static_cast<double>(physicalPaddingBottom),  // p_physical_padding_bottom
      static_cast<double>(physicalPaddingLeft),    // p_physical_padding_left
      static_cast<double>(physicalViewInsetTop),   // p_physical_view_inset_top
      static_cast<double>(
          physicalViewInsetRight),  // p_physical_view_inset_right
      static_cast<double>(
          physicalViewInsetBottom),  // p_physical_view_inset_bottom
      static_cast<double>(physicalViewInsetLeft),  // p_physical_view_inset_left
      static_cast<double>(
          systemGestureInsetTop),  // p_physical_system_gesture_inset_top
      static_cast<double>(
          systemGestureInsetRight),  // p_physical_system_gesture_inset_right
      static_cast<double>(
          systemGestureInsetBottom),  // p_physical_system_gesture_inset_bottom
      static_cast<double>(
          systemGestureInsetLeft),  // p_physical_system_gesture_inset_left
      static_cast<double>(physicalTouchSlop),  // p_physical_touch_slop
      displayFeaturesBounds,  // p_physical_display_features_bounds
      displayFeaturesType,    // p_physical_display_features_type
      displayFeaturesState,   // p_physical_display_features_state
      0,                      // p_display_id
  };
 
  ANDROID_SHELL_HOLDER->GetPlatformView()->SetViewportMetrics(
      kFlutterImplicitViewId, metrics);
}

References ANDROID_SHELL_HOLDER, and kFlutterImplicitViewId.

Referenced by RegisterApi(), and flutter::testing::TEST_F().

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

References device, and METAL_IOS_VERSION_BASELINE.

Referenced by GetRenderingAPIForProcess().

SliceViews()

std::unordered_map< int64_t, DlRect > flutter::SliceViews	(	DlCanvas *	background_canvas,
		const std::vector< int64_t > &	composition_order,
		const std::unordered_map< int64_t, std::unique_ptr< EmbedderViewSlice > > &	slices,
		const std::unordered_map< int64_t, DlRect > &	view_rects
	)

Compute the required overlay layers and clip the view slices according to the size and position of the platform views.

Definition at line 13 of file view_slicer.cc.

                                                         {
  std::unordered_map<int64_t, DlRect> overlay_layers;
 
  auto current_frame_view_count = composition_order.size();
 
  // Restore the clip context after exiting this method since it's changed
  // below.
  DlAutoCanvasRestore save(background_canvas, /*do_save=*/true);
 
  for (size_t i = 0; i < current_frame_view_count; i++) {
    int64_t view_id = composition_order[i];
    EmbedderViewSlice* slice = slices.at(view_id).get();
    if (slice->canvas() == nullptr) {
      continue;
    }
 
    slice->end_recording();
 
    DlRect full_joined_rect;
 
    // Determinate if Flutter UI intersects with any of the previous
    // platform views stacked by z position.
    //
    // This is done by querying the r-tree that holds the records for the
    // picture recorder corresponding to the flow layers added after a platform
    // view layer.
    for (int j = i; j >= 0; j--) {
      int64_t current_view_id = composition_order[j];
      auto maybe_rect = view_rects.find(current_view_id);
      FML_DCHECK(maybe_rect != view_rects.end());
      if (maybe_rect == view_rects.end()) {
        continue;
      }
 
      const DlRect current_view_rect = maybe_rect->second;
      const DlIRect rounded_in_platform_view_rect =
          DlIRect::RoundIn(current_view_rect);
      const DlRect rounded_out_platform_view_rect =
          DlRect::RoundOut(current_view_rect);
 
      // Each rect corresponds to a native view that renders Flutter UI.
      std::vector<DlIRect> intersection_rects =
          slice->region(current_view_rect).getRects();
 
      // Ignore intersections of single width/height on the edge of the platform
      // view.
      // This is to address the following performance issue when interleaving
      // adjacent platform views and layers: Since we `roundOut` both platform
      // view rects and the layer rects, as long as the coordinate is
      // fractional, there will be an intersection of a single pixel width (or
      // height) after rounding out, even if they do not intersect before
      // rounding out. We have to round out both platform view rect and the
      // layer rect. Rounding in platform view rect will result in missing pixel
      // on the intersection edge. Rounding in layer rect will result in missing
      // pixel on the edge of the layer on top of the platform view.
      for (auto it = intersection_rects.begin(); it != intersection_rects.end();
           /*no-op*/) {
        // If intersection_rect does not intersect with the *rounded in*
        // platform view rect, then the intersection must be a single pixel
        // width (or height) on edge.
        if (!it->IntersectsWithRect(rounded_in_platform_view_rect)) {
          it = intersection_rects.erase(it);
        } else {
          ++it;
        }
      }
 
      // Limit the number of native views, so it doesn't grow forever.
      //
      // In this case, the rects are merged into a single one that is the union
      // of all the rects.
      DlRect partial_joined_rect;
      for (const DlIRect& rect : intersection_rects) {
        partial_joined_rect = partial_joined_rect.Union(DlRect::Make(rect));
      }
 
      // Get the intersection rect with the `current_view_rect`,
      if (partial_joined_rect.IntersectsWithRect(
              rounded_out_platform_view_rect)) {
        // Join the `partial_joined_rect` into `full_joined_rect` to get the
        // rect above the current `slice`, only if it intersects the indicated
        // view. This should always be the case because we just deleted any
        // rects that don't intersect the "rounded-in" view, so they must
        // all intersect the "rounded-out" view (or the partial join could
        // be empty in which case this would be a NOP). Either way, the
        // penalty for not checking the return value of the intersect method
        // would be to join a non-overlapping rectangle into the overlay
        // bounds - if the above implementation ever changes - so we check it.
        full_joined_rect = full_joined_rect.Union(partial_joined_rect);
      }
    }
 
    if (!full_joined_rect.IsEmpty()) {
      overlay_layers.insert({view_id, full_joined_rect});
 
      // Clip the background canvas, so it doesn't contain any of the pixels
      // drawn on the overlay layer.
      background_canvas->ClipRect(full_joined_rect, DlClipOp::kDifference);
    }
    slice->render_into(background_canvas);
  }
 
  // Manually trigger the DlAutoCanvasRestore before we submit the frame
  save.Restore();
 
  return overlay_layers;
}

References flutter::EmbedderViewSlice::canvas(), flutter::DlCanvas::ClipRect(), flutter::EmbedderViewSlice::end_recording(), FML_DCHECK, flutter::DlRegion::getRects(), i, impeller::TRect< T >::IntersectsWithRect(), impeller::TRect< T >::IsEmpty(), kDifference, impeller::TRect< Scalar >::Make(), flutter::EmbedderViewSlice::region(), flutter::EmbedderViewSlice::render_into(), flutter::DlAutoCanvasRestore::Restore(), impeller::TRect< T >::RoundIn(), impeller::TRect< Scalar >::RoundOut(), impeller::TRect< T >::Union(), and view_id.

Referenced by flutter::AndroidExternalViewEmbedder::SubmitFlutterView(), flutter::AndroidExternalViewEmbedder2::SubmitFlutterView(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

Spawn()

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

Definition at line 555 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);
}

References ConfigureShell(), g_shell, flutter::Shell::GetTaskRunners(), flutter::RunConfiguration::InferFromSettings(), flutter::Rasterizer::kBitmap, kExistingGroup, fml::MakeCopyable(), fml::TaskRunner::RunNowOrPostTask(), and flutter::Shell::Spawn().

SpawnJNI()

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

static

Definition at line 212 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, engineId);
 
  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;
}

References ANDROID_SHELL_HOLDER, FML_LOG, g_flutter_jni_class, g_java_long_class, g_jni_constructor, g_jni_shell_holder_field, g_long_constructor, fml::jni::JavaStringToString(), and fml::jni::StringListToVector().

Referenced by RegisterApi().

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);
}

References FML_CHECK, and fml::TimeDelta::FromSeconds().

Referenced by flutter::GTestActivity::OnNativeWindowCreated().

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&) {
      return fml::TaskQueueId::Invalid();
    };
    settings.task_observer_remove = [](fml::TaskQueueId, 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);
}

References flutter::Settings::application_kernels, flutter::Shell::Create(), fml::FileMapping::CreateReadOnly(), FML_CHECK, flutter::testing::GetFixturesPath(), flutter::Shell::GetTaskRunners(), fml::TaskQueueId::Invalid(), flutter::DartVM::IsRunningPrecompiledCode(), flutter::testing::kDefaultAOTAppELFFileName, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, fml::kRead, flutter::ThreadHost::kUi, flutter::testing::LoadELFSymbolFromFixturesIfNeccessary(), fml::OpenDirectory(), flutter::testing::PrepareSettingsForAOTWithSymbols(), fml::TaskRunner::RunNowOrPostTask(), flutter::Settings::task_observer_add, flutter::Settings::task_observer_remove, and fml::AutoResetWaitableEvent::Wait().

Referenced by BM_ShellInitialization(), BM_ShellInitializationAndShutdown(), and BM_ShellShutdown().

store_points()

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

static

Definition at line 223 of file dl_vertices.cc.

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

References i, and points.

Referenced by flutter::DlVertices::Builder::store_texture_coordinates(), and flutter::DlVertices::Builder::store_vertices().

StringToAppExitType()

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

static

Definition at line 214 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;
}

References cancelable, FML_LOG, flutter::PlatformHandler::kExitTypeCancelable, flutter::PlatformHandler::kExitTypeRequired, and required.

SurfaceChanged()

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

static

Definition at line 284 of file platform_view_android_jni_impl.cc.

                                        {
  ANDROID_SHELL_HOLDER->GetPlatformView()->NotifyChanged(
      DlISize(width, height));
}

References ANDROID_SHELL_HOLDER, height, and width.

Referenced by RegisterApi().

SurfaceCreated()

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

static

Definition at line 257 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));
}

References ANDROID_SHELL_HOLDER, and window.

Referenced by RegisterApi().

SurfaceDestroyed()

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

static

Definition at line 293 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

SurfaceWindowChanged()

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

static

Definition at line 270 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));
}

References ANDROID_SHELL_HOLDER, and window.

Referenced by RegisterApi().

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().string().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;
}

References fml::FileMapping::CreateReadOnly(), FML_LOG, fml::CommandLine::GetOptionValue(), input(), fml::kReadWrite, fml::OpenDirectory(), fml::CommandLine::options(), and fml::WriteAtomically().

Referenced by main().

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, const 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);
}

References channel, flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), and message.

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]);
  }
}

References channel, flutter::StandardMessageCodec::GetInstance(), and 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]);
  }
}

References channel, flutter::StandardMessageCodec::GetInstance(), and 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, const 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);
}

References channel, flutter::StandardMessageCodec::GetInstance(), and message.

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));
}

References flutter::DartServiceIsolate::AddServerStatusCallback(), and flutter::DartServiceIsolate::RemoveServerStatusCallback().

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));
}

References 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);
  }
}

References i.

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");
}

References value.

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());
}

References value.

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());
}

References data, and value.

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());
}

References value.

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());
}

References data, and value.

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());
}

References data, and value.

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);
}

References value.

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());
}

References value.

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());
}

References flutter::EncodableValue::LongValue().

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);
}

References value.

TEST() [19/363]

flutter::TEST	(	EncodableValueTest	,
		Null
	)

Definition at line 13 of file encodable_value_unittests.cc.

                               {
  EncodableValue value;
  value.IsNull();
}

References value.

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");
}

References value.

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());
}

References data, and value.

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);
}

References channel, flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), handler, and message.

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);
}

References channel, flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), handler, and message.

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);
}

References channel, flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), handler, and message.

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);
}

References channel, flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), handler, and message.

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);
}

References channel, flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), handler, and message.

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);
}

References error.

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");
}

References error.

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);
}

References channel, flutter::StandardMethodCodec::GetInstance(), and handler.

TEST() [31/363]

flutter::TEST	(	FlowTest	,
		SurfaceFrameDoesNotHaveEmptyCanvas
	)

Definition at line 32 of file surface_frame_unittests.cc.

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

References callback, flutter::SurfaceFrame::Canvas(), flutter::DlCanvas::GetLocalClipCoverage(), impeller::TRect< T >::IsEmpty(), impeller::TRect< Scalar >::MakeLTRB(), and flutter::DlCanvas::QuickReject().

TEST() [32/363]

flutter::TEST	(	FlowTest	,
		SurfaceFrameDoesNotPrepareRtree
	)

Definition at line 49 of file surface_frame_unittests.cc.

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

References callback, and impeller::TRect< Scalar >::MakeWH().

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&) {
    EXPECT_FALSE(true);
    return true;
  };
  auto encode_callback = [](const SurfaceFrame&, DlCanvas*) {
    EXPECT_FALSE(true);
    return true;
  };
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      /*surface=*/nullptr,
      /*framebuffer_info=*/framebuffer_info,
      /*encode_callback=*/encode_callback,
      /*submit_callback=*/callback,
      /*frame_size=*/DlISize(800, 600));
  surface_frame.reset();
}

References callback.

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);
}

References engine, flutter::FlutterEngine::Start(), and flutter::testing::ScopedStubFlutterGlfwApi::stub().

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);
}

References engine, flutter::FlutterEngine::Run(), flutter::DartProject::set_dart_entrypoint(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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]);
}

References engine, flutter::DartProject::set_dart_entrypoint_arguments(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References engine, flutter::FlutterEngine::ShutDown(), flutter::FlutterEngine::Start(), and flutter::testing::ScopedStubFlutterGlfwApi::stub().

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);
}

References engine, flutter::FlutterEngine::messenger(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References engine, flutter::FlutterEngine::ProcessExternalWindowMessage(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References engine, flutter::FlutterEngine::ProcessMessages(), flutter::FlutterEngine::Run(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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());
}

References engine, flutter::FlutterEngine::ReloadSystemFonts(), flutter::FlutterEngine::Run(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References engine, flutter::FlutterEngine::RunEventLoopWithTimeout(), flutter::FlutterEngine::Start(), flutter::testing::ScopedStubFlutterGlfwApi::stub(), and UINT32_MAX.

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);
}

References engine, flutter::FlutterEngine::SetNextFrameCallback(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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\"");
}

References GetSwitchesFromEnvironment().

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);
}

References GetSwitchesFromEnvironment(), and size.

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");
}

References GetSwitchesFromEnvironment().

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");
}

References GetSwitchesFromEnvironment().

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);
}

References flutter::testing::ScopedStubFlutterGlfwApi::stub().

TEST() [49/363]

flutter::TEST	(	FlutterViewControllerTest	,
		ForceRedraw
	)

Definition at line 102 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());
}

References flutter::FlutterViewController::ForceRedraw(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

TEST() [50/363]

flutter::TEST	(	FlutterViewControllerTest	,
		GetEngine
	)

Definition at line 84 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);
}

References flutter::FlutterViewController::engine(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

TEST() [51/363]

flutter::TEST	(	FlutterViewControllerTest	,
		GetView
	)

Definition at line 93 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);
}

References flutter::testing::ScopedStubFlutterWindowsApi::stub(), and flutter::FlutterViewController::view().

TEST() [52/363]

flutter::TEST	(	FlutterViewControllerTest	,
		GetViewId
	)

Definition at line 75 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);
}

References flutter::testing::ScopedStubFlutterWindowsApi::stub(), and flutter::FlutterViewController::view_id().

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));
}

References flutter::testing::ScopedStubFlutterWindowsApi::stub(), and view.

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));
}

References flutter::testing::ScopedStubFlutterWindowsApi::stub(), and view.

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);
}

References FlutterDesktopSize::height, flutter::testing::ScopedStubFlutterGlfwApi::stub(), FlutterDesktopSize::width, and window.

TEST() [56/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameBuildEnd
	)

Definition at line 195 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());
}

References fml::TimeDelta::FromMilliseconds(), flutter::FrameTimingsRecorder::kBuildEnd, and fml::TimePoint::Now().

TEST() [57/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameBuildStart
	)

Definition at line 181 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());
}

References fml::TimeDelta::FromMilliseconds(), flutter::FrameTimingsRecorder::kBuildStart, and fml::TimePoint::Now().

TEST() [58/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameFrameNumber
	)

Definition at line 161 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());
}

References flutter::FrameTimingsRecorder::kUninitialized.

TEST() [59/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameRasterEnd
	)

Definition at line 229 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());
}

References fml::TimeDelta::FromMilliseconds(), flutter::FrameTimingsRecorder::kRasterEnd, and fml::TimePoint::Now().

TEST() [60/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameRasterEndWithCache
	)

Definition at line 254 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());
}

References flutter::testing::MockRasterCache::AddMockLayer(), flutter::testing::MockRasterCache::AddMockPicture(), flutter::RasterCache::BeginFrame(), flutter::RasterCache::EndFrame(), flutter::RasterCache::EstimateLayerCacheByteSize(), flutter::RasterCache::EstimatePictureCacheByteSize(), flutter::RasterCache::EvictUnusedCacheEntries(), fml::TimeDelta::FromMilliseconds(), flutter::FrameTimingsRecorder::kRasterEnd, and fml::TimePoint::Now().

TEST() [61/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameRasterStart
	)

Definition at line 211 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());
}

References fml::TimeDelta::FromMilliseconds(), flutter::FrameTimingsRecorder::kRasterStart, and fml::TimePoint::Now().

TEST() [62/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ClonedHasSameVsyncStartAndTarget
	)

Definition at line 169 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());
}

References fml::TimeDelta::FromMilliseconds(), flutter::FrameTimingsRecorder::kVsync, and fml::TimePoint::Now().

TEST() [63/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		FrameNumberTraceArgIsValid
	)

Definition at line 290 of file frame_timings_recorder_unittests.cc.

                                                           {
  auto recorder = std::make_unique<FrameTimingsRecorder>();
 
  std::string actual_arg =
      std::format("{}", static_cast<int>(recorder->GetFrameNumber()));
  std::string expected_arg = recorder->GetFrameNumberTraceArg();
 
  ASSERT_EQ(actual_arg, expected_arg);
}

TEST() [64/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordBuildTimes
	)

Definition at line 32 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());
}

References fml::TimeDelta::FromMillisecondsF(), and fml::TimePoint::Now().

TEST() [65/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordersHaveUniqueFrameNumbers
	)

Definition at line 154 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 48 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);
}

References fml::TimePoint::CurrentWallTime(), fml::TimeDelta::FromMillisecondsF(), and fml::TimePoint::Now().

TEST() [67/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordRasterTimesWithCache
	)

Definition at line 80 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);
}

References flutter::testing::MockRasterCache::AddMockLayer(), flutter::testing::MockRasterCache::AddMockPicture(), flutter::RasterCache::BeginFrame(), fml::TimePoint::CurrentWallTime(), flutter::RasterCache::EndFrame(), flutter::RasterCache::EstimateLayerCacheByteSize(), flutter::RasterCache::EstimatePictureCacheByteSize(), flutter::RasterCache::EvictUnusedCacheEntries(), fml::TimeDelta::FromMillisecondsF(), and fml::TimePoint::Now().

TEST() [68/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		RecordVsync
	)

Definition at line 22 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());
}

References fml::TimeDelta::FromMillisecondsF(), and fml::TimePoint::Now().

TEST() [69/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ThrowWhenRecordBuildBeforeVsync
	)

Definition at line 130 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.");
}

References fml::Status::message(), fml::TimePoint::Now(), and fml::Status::ok().

TEST() [70/363]

flutter::TEST	(	FrameTimingsRecorderTest	,
		ThrowWhenRecordRasterBeforeBuildEnd
	)

Definition at line 139 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.");
}

References fml::TimeDelta::FromMillisecondsF(), fml::Status::message(), fml::TimePoint::Now(), and fml::Status::ok().

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]);
}

References channel, message, FlutterDesktopMessage::struct_size, and user_data.

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);
}

References channel, message, FlutterDesktopMessage::struct_size, and user_data.

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);
}

References channel, message, FlutterDesktopMessage::struct_size, and user_data.

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);
}

References CheckEncodeDecode().

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::JsonMethodCodec::GetInstance(), and message.

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::JsonMethodCodec::GetInstance(), and message.

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));
}

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::JsonMethodCodec::GetInstance().

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));
}

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::JsonMethodCodec::GetInstance().

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::JsonMethodCodec::GetInstance().

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::JsonMethodCodec::GetInstance().

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);
}

References method_call.

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);
}

References flutter::MethodResult< T >::Error(), and message.

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);
}

References channel, and flutter::StandardMethodCodec::GetInstance().

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);
}

References channel, and flutter::StandardMethodCodec::GetInstance().

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);
}

References channel, flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::StandardMethodCodec::GetInstance().

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();
}

References flutter::MethodResult< T >::Error(), flutter::MethodResult< T >::NotImplemented(), and flutter::MethodResult< T >::Success().

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);
}

References flutter::MethodResult< T >::NotImplemented().

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);
}

References channel, flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), and message.

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]);
  }
}

References channel, flutter::StandardMethodCodec::GetInstance(), and 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]);
  }
}

References channel, flutter::StandardMethodCodec::GetInstance(), and 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);
}

References i, flutter::MethodResult< T >::Success(), and value.

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);
}

References channel, and flutter::StandardMethodCodec::GetInstance().

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
}

References GetExecutableDirectory().

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);
}

References flutter::PluginRegistrarGlfw::window().

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);
}

References flutter::PluginRegistrar::AddPlugin().

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));
}

References flutter::PluginRegistrarManager::GetInstance(), and manager.

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);
}

References flutter::PluginRegistrarManager::GetInstance(), manager, and flutter::testing::ScopedStubFlutterApi::stub().

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));
}

References flutter::PluginRegistrarManager::GetInstance(), and manager.

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]);
}

References message, flutter::PluginRegistrar::messenger(), flutter::BinaryMessenger::Send(), and flutter::testing::ScopedStubFlutterApi::stub().

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);
}

References message, flutter::PluginRegistrar::messenger(), flutter::BinaryMessenger::SetMessageHandler(), and flutter::testing::ScopedStubFlutterApi::stub().

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);
}

References flutter::PluginRegistrar::AddPlugin().

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);
}

References flutter::PluginRegistrar::texture_registrar(), and texture_registrar.

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);
}

References message, flutter::PluginRegistrarWindows::RegisterTopLevelWindowProcDelegate(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References flutter::PluginRegistrarWindows::GetView(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References flutter::PluginRegistrarWindows::GetView(), flutter::PluginRegistrarWindows::GetViewById(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References flutter::PluginRegistrar::AddPlugin(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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);
}

References message, flutter::PluginRegistrarWindows::RegisterTopLevelWindowProcDelegate(), flutter::testing::ScopedStubFlutterWindowsApi::stub(), and flutter::PluginRegistrarWindows::UnregisterTopLevelWindowProcDelegate().

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);
}

References message, flutter::PluginRegistrarWindows::RegisterTopLevelWindowProcDelegate(), and flutter::testing::ScopedStubFlutterWindowsApi::stub().

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());
}

References flutter::Point::x(), and flutter::Point::y().

TEST() [110/363]

flutter::TEST	(	RasterizerTest	,
		create
	)

Definition at line 130 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 164 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();
}

References flutter::ThreadHost::io_thread, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [112/363]

flutter::TEST	(	RasterizerTest	,
		drawLastLayerTreeWithThreadsMergedExternalViewEmbedderAndEndFrameCalled
	)

Definition at line 424 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  auto surface_frame2 = std::make_unique<SurfaceFrame>(
      /*surface=*/
      nullptr, framebuffer_info,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled())
      .WillRepeatedly(Return(true));
  // Prepare two frames for Draw() and DrawLastLayerTrees().
  EXPECT_CALL(*surface, AcquireFrame(DlISize()))
      .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=*/DlISize(),
                                           /*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=*/DlISize());
  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());
}

References CreateFinishedBuildRecorder(), fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), flutter::ThreadHost::io_thread, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, and flutter::ThreadHost::ui_thread.

TEST() [113/363]

flutter::TEST	(	RasterizerTest	,
		drawLayerTreeWithCorrectFrameTimingWhenPipelineIsMoreAvailable
	)

Definition at line 1065 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(DlISize()))
      .WillByDefault(::testing::Invoke([] {
        SurfaceFrame::FramebufferInfo framebuffer_info;
        framebuffer_info.supports_readback = true;
        return std::make_unique<SurfaceFrame>(
            /*surface=*/
            nullptr, framebuffer_info,
            /*encode_callback=*/
            [](const SurfaceFrame&, DlCanvas*) { return true; },
            /*submit_callback=*/[](const SurfaceFrame& frame) { return true; },
            /*frame_size=*/DlISize(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=*/DlISize());
      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();
}

References fml::CountDownLatch::CountDown(), CreateFinishedBuildRecorder(), fml::TimeDelta::FromMilliseconds(), flutter::FrameTiming::Get(), i, flutter::ThreadHost::io_thread, flutter::PipelineProduceResult::is_first_item, flutter::FrameTiming::kBuildFinish, flutter::FrameTiming::kBuildStart, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::FrameTiming::kVsyncStart, fml::TimePoint::Now(), flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, fml::CountDownLatch::Wait(), and fml::AutoResetWaitableEvent::Wait().

TEST() [114/363]

flutter::TEST	(	RasterizerTest	,
		drawMultipleViewsWithExternalViewEmbedder
	)

Definition at line 677 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(DlISize())).Times(2);
  ON_CALL(*surface, AcquireFrame).WillByDefault([](const DlISize& size) {
    SurfaceFrame::FramebufferInfo framebuffer_info;
    framebuffer_info.supports_readback = true;
    return std::make_unique<SurfaceFrame>(
        /*surface=*/
        nullptr, framebuffer_info,
        /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
        /*submit_callback=*/[](const SurfaceFrame&) { return true; },
        /*frame_size=*/DlISize(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=*/DlISize(),
                                 /*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=*/DlISize(),
                                 /*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, DlISize()), 1.5));
    tasks.push_back(std::make_unique<LayerTreeTask>(
        1, std::make_unique<LayerTree>(nullptr, DlISize()), 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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), size, flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [115/363]

flutter::TEST	(	RasterizerTest	,
		drawWithExternalViewEmbedderAndThreadMergerNotMergedExternalViewEmbedderSubmitFrameNotCalled
	)

Definition at line 273 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(DlISize()))
      .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=*/DlISize(),
                                           /*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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [116/363]

flutter::TEST	(	RasterizerTest	,
		drawWithExternalViewEmbedderAndThreadsMergedExternalViewEmbedderSubmitFrameCalled
	)

Definition at line 347 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(DlISize()))
      .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=*/DlISize(),
                                           /*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=*/DlISize());
  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);
}

References CreateFinishedBuildRecorder(), fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), flutter::ThreadHost::io_thread, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, and flutter::ThreadHost::ui_thread.

TEST() [117/363]

flutter::TEST	(	RasterizerTest	,
		drawWithExternalViewEmbedderExternalViewEmbedderSubmitFrameCalled
	)

Definition at line 194 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
  EXPECT_CALL(*surface, AcquireFrame(DlISize()))
      .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=*/DlISize(),
                                           /*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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [118/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuDisabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame
	)

Definition at line 819 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(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(DlISize()))
      .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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kDone, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [119/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuDisabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesntAcquireFrame
	)

Definition at line 944 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(false));
  EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillOnce(Return(is_gpu_disabled_sync_switch));
  EXPECT_CALL(*surface, AcquireFrame(DlISize())).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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kGpuUnavailable, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [120/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuEnabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame
	)

Definition at line 758 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(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(DlISize()))
      .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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [121/363]

flutter::TEST	(	RasterizerTest	,
		drawWithGpuEnabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesAcquireFrame
	)

Definition at line 882 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,
      /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
      /*submit_callback=*/[](const SurfaceFrame&) { return true; },
      /*frame_size=*/DlISize(800, 600));
  EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(false));
  EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch())
      .WillOnce(Return(is_gpu_disabled_sync_switch));
  EXPECT_CALL(*surface, AcquireFrame(DlISize()))
      .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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kDone, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [122/363]

flutter::TEST	(	RasterizerTest	,
		externalViewEmbedderDoesntEndFrameWhenNoSurfaceIsSet
	)

Definition at line 516 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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [123/363]

flutter::TEST	(	RasterizerTest	,
		externalViewEmbedderDoesntEndFrameWhenNotUsedThisFrame
	)

Definition at line 564 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=*/DlISize(),
                                           /*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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), flutter::ThreadHost::io_thread, kDiscarded, kDone, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [124/363]

flutter::TEST	(	RasterizerTest	,
		externalViewEmbedderDoesntEndFrameWhenPipelineIsEmpty
	)

Definition at line 632 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();
}

References flutter::ThreadHost::io_thread, flutter::ThreadHost::kIo, kPipelineEmpty, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [125/363]

flutter::TEST	(	RasterizerTest	,
		FrameTimingRecorderShouldStartRecordingRasterTimeBeforeSurfaceAcquireFrame
	)

Definition at line 1005 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(DlISize()))
      .WillByDefault(::testing::Invoke([] { return nullptr; }));
  EXPECT_CALL(*surface, AcquireFrame(DlISize()));
  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=*/DlISize());
    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();
}

References CreateFinishedBuildRecorder(), fml::TimeDelta::FromSecondsF(), flutter::FrameTiming::Get(), flutter::ThreadHost::io_thread, kDone, kFailed, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::FrameTiming::kRasterStart, flutter::ThreadHost::kUi, fml::TimePoint::Now(), flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::PipelineProduceResult::success, surface, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

TEST() [126/363]

flutter::TEST	(	RasterizerTest	,
		isAiksContextInitialized
	)

Definition at line 138 of file rasterizer_unittests.cc.

                                               {
  NiceMock<MockDelegate> delegate;
  Settings settings;
  ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
  auto rasterizer = std::make_shared<Rasterizer>(delegate);
 
  EXPECT_TRUE(rasterizer != nullptr);
  std::shared_ptr<SnapshotController::Delegate> snapshot_delegate = rasterizer;
 
  EXPECT_FALSE(snapshot_delegate->IsAiksContextInitialized());
}

TEST() [127/363]

flutter::TEST	(	RasterizerTest	,
		presentationTimeNotSetWhenVsyncTargetInPast
	)

Definition at line 1331 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(DlISize()))
      .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=*/DlISize(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=*/DlISize());
    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
}

References fml::CountDownLatch::CountDown(), CreateFinishedBuildRecorder(), fml::TimeDelta::FromMilliseconds(), flutter::ThreadHost::io_thread, flutter::PipelineProduceResult::is_first_item, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, fml::TimePoint::Now(), flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::SurfaceFrame::submit_info(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, fml::CountDownLatch::Wait(), and fml::AutoResetWaitableEvent::Wait().

TEST() [128/363]

flutter::TEST	(	RasterizerTest	,
		presentationTimeSetWhenVsyncTargetInFuture
	)

Definition at line 1242 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(DlISize()))
      .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=*/DlISize(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=*/DlISize());
      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
}

References fml::CountDownLatch::CountDown(), CreateFinishedBuildRecorder(), fml::TimeDelta::FromMilliseconds(), i, flutter::ThreadHost::io_thread, flutter::PipelineProduceResult::is_first_item, kImplicitViewId, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, fml::TimePoint::Now(), flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Signal(), flutter::SurfaceFrame::submit_info(), flutter::PipelineProduceResult::success, flutter::SurfaceFrame::FramebufferInfo::supports_readback, surface, flutter::ThreadHost::ui_thread, fml::CountDownLatch::Wait(), and fml::AutoResetWaitableEvent::Wait().

TEST() [129/363]

flutter::TEST	(	RasterizerTest	,
		TeardownFreesResourceCache
	)

Definition at line 1155 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);
}

References flutter::ThreadHost::io_thread, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, surface, and flutter::ThreadHost::ui_thread.

TEST() [130/363]

flutter::TEST	(	RasterizerTest	,
		TeardownNoSurface
	)

Definition at line 1218 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();
}

References flutter::ThreadHost::io_thread, flutter::ThreadHost::kIo, flutter::ThreadHost::kPlatform, flutter::ThreadHost::kRaster, flutter::ThreadHost::kUi, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, and flutter::ThreadHost::ui_thread.

TEST() [131/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());
}

References flutter::Rect::bottom(), flutter::Rect::left(), flutter::Rect::right(), size, and flutter::Rect::top().

TEST() [132/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());
}

References flutter::Rect::height(), size, and flutter::Rect::width().

TEST() [133/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());
}

References flutter::Rect::origin(), size, and flutter::Rect::size().

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());
}

References size.

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());
}

References size.

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);
}

References flutter::MessageCodec< T >::DecodeMessage(), and flutter::StandardMessageCodec::GetInstance().

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);
}

References CheckEncodeDecode(), and value.

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);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode().

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(""), bytes);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode(), and value.

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);
}

References CheckEncodeDecode(), and value.

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);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode(), and value.

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);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode(), and value.

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);
}

References CheckEncodeDecode(), and value.

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);
}

References CheckEncodeDecodeWithEncodePrefix(), and value.

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);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode(), and flutter::PointExtensionSerializer::GetInstance().

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("hello world"), bytes);
}

References CheckEncodeDecode().

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("h\u263Aw"), bytes);
}

References CheckEncodeDecode().

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("h\U0001F602w"), bytes);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode().

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);
}

References CheckEncodeDecode(), flutter::SomeData::data(), flutter::SomeDataExtensionSerializer::GetInstance(), and flutter::SomeData::label().

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);
}

References flutter::StandardMessageCodec::GetInstance().

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);
}

References flutter::StandardMethodCodec::GetInstance().

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);
};

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), flutter::PointExtensionSerializer::GetInstance(), and flutter::StandardMethodCodec::GetInstance().

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::StandardMethodCodec::GetInstance(), and message.

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::StandardMethodCodec::GetInstance(), and message.

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));
}

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::StandardMethodCodec::GetInstance().

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));
}

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::StandardMethodCodec::GetInstance().

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::StandardMethodCodec::GetInstance().

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);
}

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::StandardMethodCodec::GetInstance().

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);
}

References flutter::TextEditingDelta::delta_end(), flutter::TextEditingDelta::delta_start(), flutter::TextEditingDelta::delta_text(), and flutter::TextEditingDelta::old_text().

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);
}

References flutter::TextEditingDelta::delta_end(), flutter::TextEditingDelta::delta_start(), flutter::TextEditingDelta::delta_text(), and flutter::TextEditingDelta::old_text().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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)));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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));
}

References flutter::TextRange::Contains().

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());
}

References flutter::TextRange::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());
}

References flutter::TextRange::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());
}

References flutter::TextRange::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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_base().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_base().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_end().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_end().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_extent().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_extent().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_start().

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));
}

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_start().

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());
}

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), flutter::TextRange::position(), and flutter::TextRange::start().

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());
}

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), flutter::TextRange::position(), and flutter::TextRange::start().

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());
}

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), and flutter::TextRange::start().

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());
}

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), and flutter::TextRange::start().

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);
}

References flutter::TextureRegistrar::MarkTextureFrameAvailable(), and flutter::PluginRegistrar::texture_registrar().

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));
}

References height, flutter::TextureRegistrar::MarkTextureFrameAvailable(), flutter::TextureRegistrar::RegisterTexture(), fml::AutoResetWaitableEvent::Signal(), flutter::testing::ScopedStubFlutterApi::stub(), texture, texture_id, flutter::PluginRegistrar::texture_registrar(), flutter::TextureRegistrar::UnregisterTexture(), fml::AutoResetWaitableEvent::Wait(), and width.

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();
}

References fml::AutoResetWaitableEvent::Signal(), flutter::PluginRegistrar::texture_registrar(), flutter::TextureRegistrar::UnregisterTexture(), and fml::AutoResetWaitableEvent::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");
}

References flutter::DartProject::dart_entrypoint_arguments(), and flutter::DartProject::set_dart_entrypoint_arguments().

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 278 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();
}

References args, delegate_, engine, fml::AutoResetWaitableEvent::Reset(), settings_, fml::AutoResetWaitableEvent::Signal(), task_runners_, view_id, and fml::AutoResetWaitableEvent::Wait().

TEST_F() [5/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorSubmitPartialViewsForWarmUp
	)

Definition at line 605 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();
}

References delegate_, engine, settings_, fml::AutoResetWaitableEvent::Signal(), task_runners_, view_id, and fml::AutoResetWaitableEvent::Wait().

TEST_F() [6/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorSubmitsImplicitViewBeforeDrawFrameEnds
	)

Definition at line 474 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();
}

References args, CREATE_NATIVE_ENTRY, delegate_, engine, kFlutterImplicitViewId, fml::AutoResetWaitableEvent::Reset(), settings_, fml::AutoResetWaitableEvent::Signal(), task_runners_, and fml::AutoResetWaitableEvent::Wait().

TEST_F() [7/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		AnimatorSubmitWarmUpImplicitView
	)

Definition at line 538 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();
}

References delegate_, engine, kFlutterImplicitViewId, settings_, fml::AutoResetWaitableEvent::Signal(), task_runners_, and fml::AutoResetWaitableEvent::Wait().

TEST_F() [8/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		IgnoresDuplicateRenders
	)

Definition at line 398 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();
}

References args, CREATE_NATIVE_ENTRY, delegate_, engine, kFlutterImplicitViewId, tonic::DartWrappable::kPeerIndex, flutter::SceneBuilder::layer_stack(), flutter::ContainerLayer::layers(), settings_, fml::AutoResetWaitableEvent::Signal(), task_runners_, and fml::AutoResetWaitableEvent::Wait().

TEST_F() [9/19]

flutter::TEST_F	(	EngineAnimatorTest	,
		IgnoresOutOfFrameRenders
	)

Definition at line 341 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();
}

References delegate_, engine, settings_, fml::AutoResetWaitableEvent::Signal(), task_runners_, and fml::AutoResetWaitableEvent::Wait().

TEST_F() [10/19]

flutter::TEST_F	(	EngineTest	,
		Create
	)

Definition at line 253 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);
  });
}

References animator_, delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, runtime_controller_, settings_, and task_runners_.

TEST_F() [11/19]

flutter::TEST_F	(	EngineTest	,
		DispatchPlatformMessageInitialRoute
	)

Definition at line 297 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");
  });
}

References animator_, delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, message, settings_, and task_runners_.

TEST_F() [12/19]

flutter::TEST_F	(	EngineTest	,
		DispatchPlatformMessageInitialRouteIgnored
	)

Definition at line 329 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(), "");
  });
}

References animator_, delegate_, dispatcher_maker_, DispatchPlatformMessage(), engine, image_decoder_task_runner_, io_manager_, message, settings_, and task_runners_.

TEST_F() [13/19]

flutter::TEST_F	(	EngineTest	,
		DispatchPlatformMessageUnknown
	)

Definition at line 270 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));
  });
}

References animator_, delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, message, settings_, and task_runners_.

TEST_F() [14/19]

flutter::TEST_F	(	EngineTest	,
		PassesLoadDartDeferredLibraryErrorToRuntime
	)

Definition at line 456 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);
  });
}

References animator_, delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, settings_, and task_runners_.

TEST_F() [15/19]

flutter::TEST_F	(	EngineTest	,
		SpawnedEngineInheritsAssetManager
	)

Definition at line 484 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());
  });
}

References animator_, flutter::DartVMRef::Create(), delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, settings_, snapshot_delegate_, and task_runners_.

TEST_F() [16/19]

flutter::TEST_F	(	EngineTest	,
		SpawnSharesFontLibrary
	)

Definition at line 363 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());
  });
}

References animator_, flutter::DartVMRef::Create(), delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, settings_, snapshot_delegate_, and task_runners_.

TEST_F() [17/19]

flutter::TEST_F	(	EngineTest	,
		SpawnWithCustomInitialRoute
	)

Definition at line 391 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());
  });
}

References animator_, flutter::DartVMRef::Create(), delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, settings_, snapshot_delegate_, and task_runners_.

TEST_F() [18/19]

flutter::TEST_F	(	EngineTest	,
		SpawnWithCustomSettings
	)

Definition at line 419 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());
  });
}

References animator_, flutter::DartVMRef::Create(), delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, flutter::Settings::persistent_isolate_data, settings_, snapshot_delegate_, and task_runners_.

TEST_F() [19/19]

flutter::TEST_F	(	EngineTest	,
		UpdateAssetManagerWithEqualManagers
	)

Definition at line 523 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);
  });
}

References animator_, flutter::DartVMRef::Create(), delegate_, dispatcher_maker_, engine, image_decoder_task_runner_, io_manager_, settings_, and task_runners_.

ThreadExitCallback()

void flutter::ThreadExitCallback

(

)

Definition at line 152 of file dart_vm.cc.

{}

ToApproximateSkRRect()

const SkRRect flutter::ToApproximateSkRRect ( const DlRoundSuperellipse &  rse )

inline

Definition at line 155 of file dl_geometry_conversions.h.

                                                                          {
  return ToSkRRect(rse.ToApproximateRoundRect());
};

References impeller::RoundSuperellipse::ToApproximateRoundRect(), and ToSkRRect().

Referenced by flutter::DlSkCanvasAdapter::ClipRoundSuperellipse(), flutter::DlSkCanvasDispatcher::clipRoundSuperellipse(), flutter::DlSkCanvasDispatcher::drawRoundSuperellipse(), flutter::DlSkCanvasAdapter::DrawRoundSuperellipse(), and flutter::testing::TEST().

ToDlIRect()

const DlIRect & flutter::ToDlIRect ( const SkIRect &  rect )

inline

Definition at line 38 of file dl_geometry_conversions.h.

                                                     {
  return *reinterpret_cast<const DlIRect*>(&rect);
}

Referenced by flutter::testing::CheckEquality(), flutter::DlImageFilter::inset_device_bounds(), flutter::DlImageFilter::outset_device_bounds(), flutter::testing::SkJobRenderer::Render(), flutter::RTree::searchNonOverlappingDrawnRects(), and flutter::testing::TEST().

ToDlISize()

const DlISize & flutter::ToDlISize ( const SkISize &  size )

inline

Definition at line 42 of file dl_geometry_conversions.h.

                                                     {
  return *reinterpret_cast<const DlISize*>(&size);
}

References size.

Referenced by flutter::SnapshotControllerSkia::ConvertToRasterImage(), flutter::DlSkCanvasAdapter::GetBaseLayerDimensions(), flutter::DlImageSkia::GetSize(), flutter::DlDeferredImageGPUSkia::GetSize(), flutter::DlImageGPU::GetSize(), and flutter::testing::TEST().

ToDlMatrix() [1/3]

DlMatrix flutter::ToDlMatrix ( const SkM44 &  matrix )

inline

Definition at line 72 of file dl_geometry_conversions.h.

                                                {
  DlMatrix dl_matrix;
  matrix.getColMajor(dl_matrix.m);
  return dl_matrix;
}

References impeller::Matrix::m.

ToDlMatrix() [2/3]

DlMatrix flutter::ToDlMatrix ( const SkMatrix &  matrix )

inline

Definition at line 61 of file dl_geometry_conversions.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
}

References impeller::Matrix::MakeColumn().

Referenced by flutter::testing::MockRasterCache::AddMockPicture(), flutter::SurfaceTextureExternalTexture::DrawFrame(), flutter::DlSkCanvasAdapter::GetMatrix(), flutter::CanvasGradient::initLinear(), flutter::ImageFilter::initMatrix(), flutter::CanvasGradient::initRadial(), flutter::CanvasGradient::initSweep(), flutter::CanvasGradient::initTwoPointConical(), flutter::ImageShader::initWithImage(), flutter::SceneBuilder::pushTransform(), flutter::RasterCache::Rasterize(), flutter::testing::SkJobRenderer::Render(), and flutter::testing::TEST().

ToDlMatrix() [3/3]

DlMatrix flutter::ToDlMatrix

(

const tonic::Float64List &

matrix4

)

Definition at line 46 of file matrix.cc.

                                                     {
  FML_DCHECK(matrix4.data());
  // clang-format off
  return DlMatrix::MakeColumn(
    SafeNarrow(matrix4[ 0]), SafeNarrow(matrix4[ 1]), SafeNarrow(matrix4[ 2]), SafeNarrow(matrix4[ 3]),
    SafeNarrow(matrix4[ 4]), SafeNarrow(matrix4[ 5]), SafeNarrow(matrix4[ 6]), SafeNarrow(matrix4[ 7]),
    SafeNarrow(matrix4[ 8]), SafeNarrow(matrix4[ 9]), SafeNarrow(matrix4[10]), SafeNarrow(matrix4[11]),
    SafeNarrow(matrix4[12]), SafeNarrow(matrix4[13]), SafeNarrow(matrix4[14]), SafeNarrow(matrix4[15])
  );
  // clang-format on
}

References FML_DCHECK, impeller::Matrix::MakeColumn(), and SafeNarrow().

ToDlPoint()

const DlPoint & flutter::ToDlPoint ( const SkPoint &  point )

inline

Definition at line 26 of file dl_geometry_conversions.h.

                                                      {
  return *reinterpret_cast<const DlPoint*>(&point);
}

Referenced by flutter::DlPath::Dispatch(), flutter::DlPath::IsLine(), and flutter::testing::TEST().

ToDlRect() [1/2]

const DlRect flutter::ToDlRect ( const SkIRect &  rect )

inline

Definition at line 34 of file dl_geometry_conversions.h.

                                                  {
  return DlRect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
}

References impeller::TRect< Scalar >::MakeLTRB().

ToDlRect() [2/2]

const DlRect & flutter::ToDlRect ( const SkRect &  rect )

inline

Definition at line 30 of file dl_geometry_conversions.h.

                                                  {
  return *reinterpret_cast<const DlRect*>(&rect);
}

Referenced by flutter::RasterCacheResult::draw(), flutter::DlSkCanvasDispatcher::drawDisplayList(), flutter::DlSkCanvasAdapter::DrawDisplayList(), flutter::DlTextSkia::GetBounds(), flutter::DlPath::GetBounds(), flutter::DlSkCanvasAdapter::GetDestinationClipCoverage(), flutter::DlSkCanvasAdapter::GetLocalClipCoverage(), flutter::RasterCache::Rasterize(), flutter::testing::CanvasCompareTester::RenderWith(), flutter::testing::TEST(), and ToDlRoundRect().

ToDlRoundRect()

const DlRoundRect flutter::ToDlRoundRect ( const SkRRect &  rrect )

inline

Definition at line 50 of file dl_geometry_conversions.h.

                                                             {
  return DlRoundRect::MakeRectRadii(
      ToDlRect(rrect.rect()),
      {
          .top_left = ToDlSize(rrect.radii(SkRRect::kUpperLeft_Corner)),
          .top_right = ToDlSize(rrect.radii(SkRRect::kUpperRight_Corner)),
          .bottom_left = ToDlSize(rrect.radii(SkRRect::kLowerLeft_Corner)),
          .bottom_right = ToDlSize(rrect.radii(SkRRect::kLowerRight_Corner)),
      });
}

References impeller::RoundRect::MakeRectRadii(), and ToDlRect().

Referenced by flutter::DlPath::IsRoundRect().

ToDlSize()

const DlSize & flutter::ToDlSize ( const SkVector &  vector )

inline

Definition at line 46 of file dl_geometry_conversions.h.

                                                      {
  return *reinterpret_cast<const DlSize*>(&vector);
}

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

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

ToMatrix4()

tonic::Float64List flutter::ToMatrix4

(

const SkMatrix &

sk_matrix

)

Definition at line 58 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;
}

References i, kSkMatrixIndexToMatrix4Index, and sk_matrix.

ToNonShaderSk()

SkPaint flutter::ToNonShaderSk

(

const DlPaint &

paint

)

Definition at line 67 of file dl_sk_conversions.cc.

                                            {
  DlPaint non_shader_paint = paint;
  non_shader_paint.setColorSource(nullptr);
  return ToSk(non_shader_paint);
}

References flutter::DlPaint::setColorSource(), and ToSk().

Referenced by flutter::SkOptionalPaint::SkOptionalPaint(), and flutter::testing::TEST().

ToOptSkIRect()

std::optional< const SkIRect > flutter::ToOptSkIRect ( std::optional< const DlIRect >  rect )

inline

Definition at line 98 of file dl_geometry_conversions.h.

                                     {
  return rect.has_value() ? std::optional(ToSkIRect(*rect)) : std::nullopt;
}

References ToSkIRect().

ToSk() [1/28]

SkBlurStyle flutter::ToSk ( const DlBlurStyle  blur_style )

inline

Definition at line 52 of file dl_sk_conversions.h.

                                                      {
  return static_cast<SkBlurStyle>(blur_style);
}

ToSk() [2/28]

sk_sp< SkColorFilter > flutter::ToSk ( const DlColorFilter &  filter )

inline

Definition at line 111 of file dl_sk_conversions.h.

                                                              {
  return ToSk(&filter);
}

References ToSk().

ToSk() [3/28]

sk_sp< SkColorFilter > flutter::ToSk

(

const DlColorFilter *

filter

)

Definition at line 244 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(ToSkColor4f(blend_filter->color()), nullptr,
                                   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();
    }
  }
}

References flutter::DlColorFilter::asBlend(), flutter::DlColorFilter::asMatrix(), flutter::DlBlendColorFilter::color(), FML_DCHECK, flutter::DlMatrixColorFilter::get_matrix(), kBlend, kLinearToSrgbGamma, kMatrix, kSrgbToLinearGamma, flutter::DlBlendColorFilter::mode(), ToSk(), ToSkColor4f(), and flutter::DlAttribute< D, T >::type().

ToSk() [4/28]

sk_sp< SkShader > flutter::ToSk ( const DlColorSource &  source )

inline

Definition at line 94 of file dl_sk_conversions.h.

                                                         {
  return ToSk(&source);
}

References ToSk().

ToSk() [5/28]

sk_sp< SkShader > flutter::ToSk

(

const DlColorSource *

source

)

Definition at line 73 of file dl_sk_conversions.cc.

                                                  {
  if (!source) {
    return nullptr;
  }
  SkMatrix scratch;
  static auto ToSkColors =
      [](const DlGradientColorSourceBase* gradient) -> std::vector<SkColor> {
    std::vector<SkColor> sk_colors;
    sk_colors.reserve(gradient->stop_count());
    for (int i = 0; i < gradient->stop_count(); ++i) {
      sk_colors.push_back(gradient->colors()[i].argb());
    }
    return sk_colors;
  };
  switch (source->type()) {
    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()),
          ToSk(image_source->matrix_ptr(), scratch));
    }
    case DlColorSourceType::kLinearGradient: {
      const DlLinearGradientColorSource* linear_source =
          source->asLinearGradient();
      FML_DCHECK(linear_source != nullptr);
      SkPoint pts[] = {ToSkPoint(linear_source->start_point()),
                       ToSkPoint(linear_source->end_point())};
      std::vector<SkColor> skcolors = ToSkColors(linear_source);
      return SkGradientShader::MakeLinear(
          pts, skcolors.data(), linear_source->stops(),
          linear_source->stop_count(), ToSk(linear_source->tile_mode()), 0,
          ToSk(linear_source->matrix_ptr(), scratch));
    }
    case DlColorSourceType::kRadialGradient: {
      const DlRadialGradientColorSource* radial_source =
          source->asRadialGradient();
      FML_DCHECK(radial_source != nullptr);
      return SkGradientShader::MakeRadial(
          ToSkPoint(radial_source->center()), radial_source->radius(),
          ToSkColors(radial_source).data(), radial_source->stops(),
          radial_source->stop_count(), ToSk(radial_source->tile_mode()), 0,
          ToSk(radial_source->matrix_ptr(), scratch));
    }
    case DlColorSourceType::kConicalGradient: {
      const DlConicalGradientColorSource* conical_source =
          source->asConicalGradient();
      FML_DCHECK(conical_source != nullptr);
      return SkGradientShader::MakeTwoPointConical(
          ToSkPoint(conical_source->start_center()),
          conical_source->start_radius(),
          ToSkPoint(conical_source->end_center()), conical_source->end_radius(),
          ToSkColors(conical_source).data(), conical_source->stops(),
          conical_source->stop_count(), ToSk(conical_source->tile_mode()), 0,
          ToSk(conical_source->matrix_ptr(), scratch));
    }
    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).data(), sweep_source->stops(),
          sweep_source->stop_count(), ToSk(sweep_source->tile_mode()),
          sweep_source->start(), sweep_source->end(), 0,
          ToSk(sweep_source->matrix_ptr(), scratch));
    }
    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++) {
        const 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());
    }
  }
}

References flutter::DlColorSource::asConicalGradient(), flutter::DlColorSource::asImage(), flutter::DlColorSource::asLinearGradient(), flutter::DlColorSource::asRadialGradient(), flutter::DlColorSource::asRuntimeEffect(), flutter::DlColorSource::asSweepGradient(), flutter::DlRadialGradientColorSource::center(), flutter::DlSweepGradientColorSource::center(), data, flutter::DlSweepGradientColorSource::end(), flutter::DlConicalGradientColorSource::end_center(), flutter::DlLinearGradientColorSource::end_point(), flutter::DlConicalGradientColorSource::end_radius(), FML_DCHECK, flutter::DlImageColorSource::horizontal_tile_mode(), i, flutter::DlImageColorSource::image(), image, kConicalGradient, kImage, kLinearGradient, kRadialGradient, kRuntimeEffect, kSweepGradient, flutter::DlMatrixColorSourceBase::matrix_ptr(), flutter::DlRadialGradientColorSource::radius(), flutter::DlRuntimeEffectColorSource::runtime_effect(), flutter::DlRuntimeEffectColorSource::samplers(), flutter::DlImageColorSource::sampling(), flutter::DlSweepGradientColorSource::start(), flutter::DlConicalGradientColorSource::start_center(), flutter::DlLinearGradientColorSource::start_point(), flutter::DlConicalGradientColorSource::start_radius(), flutter::DlGradientColorSourceBase::stop_count(), flutter::DlGradientColorSourceBase::stops(), flutter::DlGradientColorSourceBase::tile_mode(), ToSk(), ToSkPoint(), flutter::DlAttribute< D, T >::type(), flutter::DlRuntimeEffectColorSource::uniform_data(), flutter::DlImageColorSource::vertical_tile_mode(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

ToSk() [6/28]

SkFilterMode flutter::ToSk ( const DlFilterMode  filter_mode )

inline

Definition at line 56 of file dl_sk_conversions.h.

                                                         {
  return static_cast<SkFilterMode>(filter_mode);
}

ToSk() [7/28]

sk_sp< SkImageFilter > flutter::ToSk ( const DlImageFilter &  filter )

inline

Definition at line 102 of file dl_sk_conversions.h.

                                                              {
  return ToSk(&filter);
}

References ToSk().

ToSk() [8/28]

sk_sp< SkImageFilter > flutter::ToSk

(

const DlImageFilter *

filter

)

Definition at line 181 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(
          ToSkMatrix(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(ToSkMatrix(lm_filter->matrix()));
    }
    case DlImageFilterType::kRuntimeEffect:
      // UNSUPPORTED.
      return nullptr;
  }
}

References flutter::DlImageFilter::asBlur(), flutter::DlImageFilter::asColorFilter(), flutter::DlImageFilter::asCompose(), flutter::DlImageFilter::asDilate(), flutter::DlImageFilter::asErode(), flutter::DlImageFilter::asLocalMatrix(), flutter::DlImageFilter::asMatrix(), flutter::DlColorFilterImageFilter::color_filter(), FML_DCHECK, flutter::DlLocalMatrixImageFilter::image_filter(), flutter::DlComposeImageFilter::inner(), kBlur, kColorFilter, kCompose, kDilate, kErode, kLocalMatrix, kMatrix, kRuntimeEffect, flutter::DlLocalMatrixImageFilter::matrix(), flutter::DlMatrixImageFilter::matrix(), flutter::DlComposeImageFilter::outer(), flutter::DlDilateImageFilter::radius_x(), flutter::DlErodeImageFilter::radius_x(), flutter::DlDilateImageFilter::radius_y(), flutter::DlErodeImageFilter::radius_y(), flutter::DlMatrixImageFilter::sampling(), flutter::DlBlurImageFilter::sigma_x(), flutter::DlBlurImageFilter::sigma_y(), flutter::DlBlurImageFilter::tile_mode(), ToSk(), ToSkMatrix(), and flutter::DlAttribute< D, T >::type().

ToSk() [9/28]

sk_sp< SkMaskFilter > flutter::ToSk ( const DlMaskFilter &  filter )

inline

Definition at line 120 of file dl_sk_conversions.h.

                                                            {
  return ToSk(&filter);
}

References ToSk().

ToSk() [10/28]

sk_sp< SkMaskFilter > flutter::ToSk

(

const DlMaskFilter *

filter

)

Definition at line 271 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());
    }
  }
}

References flutter::DlMaskFilter::asBlur(), FML_DCHECK, kBlur, flutter::DlBlurMaskFilter::respectCTM(), flutter::DlBlurMaskFilter::sigma(), flutter::DlBlurMaskFilter::style(), ToSk(), and flutter::DlAttribute< D, T >::type().

ToSk() [11/28]

SkMatrix * flutter::ToSk ( const DlMatrix *  matrix, SkMatrix &  scratch  )

inline

Definition at line 124 of file dl_sk_conversions.h.

                                                                 {
  return matrix ? &scratch.setAll(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])
                : nullptr;
}

References impeller::Matrix::m.

ToSk() [12/28]

SkPaint flutter::ToSk

(

const DlPaint &

paint

)

Definition at line 27 of file dl_sk_conversions.cc.

                                   {
  SkPaint sk_paint;
 
  sk_paint.setAntiAlias(paint.isAntiAlias());
  sk_paint.setColor(ToSkColor4f(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;
}

References flutter::DlPaint::getBlendMode(), flutter::DlPaint::getColor(), flutter::DlPaint::getColorFilterPtr(), flutter::DlPaint::getColorSourcePtr(), flutter::DlPaint::getDrawStyle(), flutter::DlPaint::getImageFilterPtr(), flutter::DlPaint::getMaskFilterPtr(), flutter::DlPaint::getStrokeCap(), flutter::DlPaint::getStrokeJoin(), flutter::DlPaint::getStrokeMiter(), flutter::DlPaint::getStrokeWidth(), flutter::DlPaint::isAntiAlias(), flutter::DlPaint::isInvertColors(), kInvertColorMatrix, ToSk(), and ToSkColor4f().

Referenced by flutter::DlSkCanvasAdapter::ClipOval(), flutter::DlSkCanvasDispatcher::clipOval(), flutter::DlSkCanvasAdapter::ClipPath(), flutter::DlSkCanvasDispatcher::clipPath(), flutter::DlSkCanvasAdapter::ClipRect(), flutter::DlSkCanvasDispatcher::clipRect(), flutter::DlSkCanvasAdapter::ClipRoundRect(), flutter::DlSkCanvasDispatcher::clipRoundRect(), flutter::DlSkCanvasAdapter::ClipRoundSuperellipse(), flutter::DlSkCanvasDispatcher::clipRoundSuperellipse(), flutter::DlSkCanvasAdapter::DrawArc(), flutter::DlSkCanvasAdapter::DrawAtlas(), flutter::DlSkCanvasDispatcher::drawAtlas(), flutter::DlSkCanvasAdapter::DrawCircle(), flutter::DlSkCanvasAdapter::DrawColor(), flutter::DlSkCanvasDispatcher::drawColor(), flutter::DlSkCanvasAdapter::DrawDiffRoundRect(), flutter::DlSkCanvasAdapter::DrawImage(), flutter::DlSkCanvasDispatcher::drawImage(), flutter::DlSkCanvasAdapter::DrawImageNine(), flutter::DlSkCanvasDispatcher::drawImageNine(), flutter::DlSkCanvasAdapter::DrawImageRect(), flutter::DlSkCanvasDispatcher::drawImageRect(), flutter::DlSkCanvasAdapter::DrawOval(), flutter::DlSkCanvasAdapter::DrawPaint(), flutter::DlSkCanvasAdapter::DrawPath(), flutter::DlSkCanvasDispatcher::drawPoints(), flutter::DlSkCanvasAdapter::DrawPoints(), flutter::DlSkCanvasAdapter::DrawRect(), flutter::DlSkCanvasAdapter::DrawRoundRect(), flutter::DlSkCanvasAdapter::DrawRoundSuperellipse(), flutter::DlSkCanvasAdapter::DrawText(), flutter::DlSkCanvasDispatcher::drawVertices(), flutter::DlSkCanvasAdapter::DrawVertices(), flutter::DlSkCanvasDispatcher::saveLayer(), flutter::DlSkCanvasAdapter::SaveLayer(), flutter::DlSkPaintDispatchHelper::setBlendMode(), flutter::DlSkPaintDispatchHelper::setColorFilter(), flutter::DlSkPaintDispatchHelper::setColorSource(), flutter::DlSkPaintDispatchHelper::setDrawStyle(), flutter::DlSkPaintDispatchHelper::setImageFilter(), flutter::DlSkPaintDispatchHelper::setMaskFilter(), flutter::DlSkPaintDispatchHelper::setStrokeCap(), flutter::DlSkPaintDispatchHelper::setStrokeJoin(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::DisplayListNopTest::test_attributes_image(), ToNonShaderSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), ToSk(), and ToStrokedSk().

ToSk() [13/28]

const SkRSXform * flutter::ToSk ( const DlRSTransform *  transforms )

inline

Definition at line 133 of file dl_sk_conversions.h.

                                                              {
  return reinterpret_cast<const SkRSXform*>(transforms);
}

ToSk() [14/28]

sk_sp< SkColorFilter > flutter::ToSk ( const std::shared_ptr< const DlColorFilter > &  filter )

inline

Definition at line 107 of file dl_sk_conversions.h.

                                                      {
  return ToSk(filter.get());
}

References ToSk().

ToSk() [15/28]

sk_sp< SkShader > flutter::ToSk ( const std::shared_ptr< const DlColorSource > &  source )

inline

Definition at line 90 of file dl_sk_conversions.h.

                                                      {
  return ToSk(source.get());
}

References ToSk().

ToSk() [16/28]

sk_sp< SkMaskFilter > flutter::ToSk ( const std::shared_ptr< const DlMaskFilter > &  filter )

inline

Definition at line 116 of file dl_sk_conversions.h.

                                                     {
  return ToSk(filter.get());
}

References ToSk().

ToSk() [17/28]

sk_sp< SkImageFilter > flutter::ToSk ( const std::shared_ptr< DlImageFilter > &  filter )

inline

Definition at line 99 of file dl_sk_conversions.h.

                                                                             {
  return ToSk(filter.get());
}

References ToSk().

ToSk() [18/28]

sk_sp< SkVertices > flutter::ToSk

(

const std::shared_ptr< DlVertices > &

vertices

)

Definition at line 286 of file dl_sk_conversions.cc.

                                                                  {
  std::vector<SkColor> sk_colors;
  const SkColor* sk_colors_ptr = nullptr;
  if (vertices->colors()) {
    sk_colors.reserve(vertices->vertex_count());
    for (int i = 0; i < vertices->vertex_count(); ++i) {
      sk_colors.push_back(vertices->colors()[i].argb());
    }
    sk_colors_ptr = sk_colors.data();
  }
  return SkVertices::MakeCopy(ToSk(vertices->mode()), vertices->vertex_count(),
                              ToSkPoints(vertices->vertex_data()),
                              ToSkPoints(vertices->texture_coordinate_data()),
                              sk_colors_ptr, vertices->index_count(),
                              vertices->indices());
}

References i, ToSk(), and ToSkPoints().

ToSk() [19/28]

SkBlendMode flutter::ToSk ( DlBlendMode  mode )

inline

Definition at line 17 of file dl_sk_conversions.h.

                                          {
  return static_cast<SkBlendMode>(mode);
}

References mode.

ToSk() [20/28]

SkClipOp flutter::ToSk ( DlClipOp  op )

inline

Definition at line 81 of file dl_sk_conversions.h.

                                  {
  return static_cast<SkClipOp>(op);
}

ToSk() [21/28]

SkPaint::Style flutter::ToSk ( DlDrawStyle  style )

inline

Definition at line 36 of file dl_sk_conversions.h.

                                            {
  return static_cast<SkPaint::Style>(style);
}

ToSk() [22/28]

SkSamplingOptions flutter::ToSk ( DlImageSampling  sampling )

inline

Definition at line 64 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);
  }
}

References kCubic, kLinear, kMipmapLinear, and kNearestNeighbor.

ToSk() [23/28]

SkCanvas::PointMode flutter::ToSk ( DlPointMode  mode )

inline

Definition at line 85 of file dl_sk_conversions.h.

                                                {
  return static_cast<SkCanvas::PointMode>(mode);
}

References mode.

ToSk() [24/28]

SkCanvas::SrcRectConstraint flutter::ToSk ( DlSrcRectConstraint  constraint )

inline

Definition at line 77 of file dl_sk_conversions.h.

                                                                      {
  return static_cast<SkCanvas::SrcRectConstraint>(constraint);
}

ToSk() [25/28]

SkPaint::Cap flutter::ToSk ( DlStrokeCap  cap )

inline

Definition at line 40 of file dl_sk_conversions.h.

                                        {
  return static_cast<SkPaint::Cap>(cap);
}

ToSk() [26/28]

SkPaint::Join flutter::ToSk ( DlStrokeJoin  join )

inline

Definition at line 44 of file dl_sk_conversions.h.

                                           {
  return static_cast<SkPaint::Join>(join);
}

ToSk() [27/28]

SkTileMode flutter::ToSk ( DlTileMode  dl_mode )

inline

Definition at line 48 of file dl_sk_conversions.h.

                                           {
  return static_cast<SkTileMode>(dl_mode);
}

ToSk() [28/28]

SkVertices::VertexMode flutter::ToSk ( DlVertexMode  dl_mode )

inline

Definition at line 60 of file dl_sk_conversions.h.

                                                       {
  return static_cast<SkVertices::VertexMode>(dl_mode);
}

ToSkColor()

SkColor flutter::ToSkColor ( DlColor  color )

inline

Definition at line 32 of file dl_sk_conversions.h.

                                        {
  return color.argb();
}

References flutter::DlColor::argb().

Referenced by flutter::DlSkCanvasDispatcher::DrawShadow(), and flutter::testing::TEST().

ToSkColor4f()

SkColor4f flutter::ToSkColor4f ( DlColor  color )

inline

Definition at line 22 of file dl_sk_conversions.h.

                                            {
  if (color.getColorSpace() == DlColorSpace::kSRGB ||
      color.getColorSpace() == DlColorSpace::kExtendedSRGB) {
    return SkColor4f{color.getRedF(), color.getGreenF(), color.getBlueF(),
                     color.getAlphaF()};
  } else {
    return ToSkColor4f(color.withColorSpace(DlColorSpace::kExtendedSRGB));
  }
}

References flutter::DlColor::getAlphaF(), flutter::DlColor::getBlueF(), flutter::DlColor::getColorSpace(), flutter::DlColor::getGreenF(), flutter::DlColor::getRedF(), kExtendedSRGB, kSRGB, ToSkColor4f(), and flutter::DlColor::withColorSpace().

Referenced by flutter::DlSkCanvasAdapter::DrawColor(), flutter::DlSkCanvasDispatcher::drawColor(), flutter::testing::RenderEnvironment::getResult(), flutter::testing::CanvasCompareTester::RenderWithSaveRestore(), flutter::DlSkPaintDispatchHelper::setColor(), flutter::testing::TEST(), flutter::testing::DisplayListNopTest::test_attributes_image(), flutter::testing::DisplayListNopTest::test_mode_color_via_filter(), flutter::testing::DisplayListNopTest::test_mode_color_via_rendering(), ToSk(), ToSk(), and ToSkColor4f().

ToSkIRect()

const SkIRect & flutter::ToSkIRect ( const DlIRect &  rect )

inline

Definition at line 94 of file dl_geometry_conversions.h.

                                                     {
  return *reinterpret_cast<const SkIRect*>(&rect);
}

Referenced by flutter::RasterCacheResult::draw(), flutter::DlSkCanvasAdapter::DrawImageNine(), flutter::DlSkCanvasDispatcher::drawImageNine(), flutter::RTree::searchNonOverlappingDrawnRects(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and ToOptSkIRect().

ToSkIRects()

const SkIRect * flutter::ToSkIRects ( const DlIRect *  rects )

inline

Definition at line 119 of file dl_geometry_conversions.h.

                                                       {
  return rects == nullptr ? nullptr : reinterpret_cast<const SkIRect*>(rects);
}

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

ToSkISize()

const SkISize & flutter::ToSkISize ( const DlISize &  size )

inline

Definition at line 127 of file dl_geometry_conversions.h.

                                                     {
  return *reinterpret_cast<const SkISize*>(&size);
}

References size.

Referenced by flutter::ImageEncodingImpeller::ConvertDlImageToSkImage(), flutter::RasterCacheResult::image_dimensions(), flutter_runner::ExternalViewEmbedder::PrepareFlutterView(), and flutter::testing::TEST().

ToSkM44() [1/2]

SkM44 flutter::ToSkM44 ( const DlMatrix &  matrix )

inline

Definition at line 165 of file dl_geometry_conversions.h.

                                             {
  return SkM44::ColMajor(matrix.m);
}

References impeller::Matrix::m.

Referenced by flutter::GPUSurfaceGLSkia::AcquireFrame(), flutter::testing::CanvasCompareTester::RenderWithTransforms(), flutter::DlSkCanvasAdapter::SetTransform(), and flutter::DlSkCanvasAdapter::Transform().

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
}

References SafeNarrow().

ToSkMatrix() [1/2]

SkMatrix flutter::ToSkMatrix ( const DlMatrix &  matrix )

inline

Definition at line 159 of file dl_geometry_conversions.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]);
}

References impeller::Matrix::m.

Referenced by flutter::CanvasPath::addPathWithMatrix(), flutter::RasterCache::Draw(), flutter::RasterCacheResult::draw(), flutter::CanvasPath::extendWithPathAndMatrix(), flutter::DlImageFilter::inset_device_bounds(), flutter::DlImageFilter::outset_device_bounds(), flutter::DisplayListRasterCacheItem::PrerollFinalize(), flutter::DisplayListRasterCacheItem::PrerollSetup(), flutter::testing::CanvasCompareTester::RenderWithTransforms(), flutter::RasterCacheItem::set_matrix(), flutter_runner::ExternalViewEmbedder::SubmitFlutterView(), flutter::testing::TEST(), ToSk(), and flutter::CanvasPath::transform().

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

References FML_DCHECK, i, kSkMatrixIndexToMatrix4Index, SafeNarrow(), and sk_matrix.

ToSkPoint()

const SkPoint & flutter::ToSkPoint ( const DlPoint &  point )

inline

Definition at line 78 of file dl_geometry_conversions.h.

                                                      {
  return *reinterpret_cast<const SkPoint*>(&point);
}

Referenced by flutter::DlPathBuilder::AddArc(), flutter::DisplayListLayer::DisplayListLayer(), flutter::DlSkCanvasDispatcher::drawCircle(), flutter::DlSkCanvasAdapter::DrawCircle(), flutter::DlSkCanvasDispatcher::drawDashedLine(), flutter::DlSkCanvasAdapter::DrawDashedLine(), flutter::DlSkCanvasDispatcher::drawLine(), flutter::DlSkCanvasAdapter::DrawLine(), flutter::DlPath::MakeArc(), flutter::DlPath::MakeLine(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and ToSk().

ToSkPoints() [1/2]

const SkPoint * flutter::ToSkPoints ( const DlPoint *  points )

inline

Definition at line 82 of file dl_geometry_conversions.h.

                                                        {
  return points == nullptr ? nullptr : reinterpret_cast<const SkPoint*>(points);
}

References points.

Referenced by flutter::DlSkCanvasDispatcher::drawPoints(), flutter::DlSkCanvasAdapter::DrawPoints(), flutter::DlPath::MakePoly(), flutter::testing::CanvasCompareTester::RenderWithAttributes(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and ToSk().

ToSkPoints() [2/2]

SkPoint * flutter::ToSkPoints ( DlPoint *  points )

inline

Definition at line 86 of file dl_geometry_conversions.h.

                                            {
  return points == nullptr ? nullptr : reinterpret_cast<SkPoint*>(points);
}

References points.

ToSkRect() [1/4]

const SkRect & flutter::ToSkRect ( const DlRect &  rect )

inline

Definition at line 90 of file dl_geometry_conversions.h.

                                                  {
  return *reinterpret_cast<const SkRect*>(&rect);
}

Referenced by flutter::DlPathBuilder::AddArc(), flutter::testing::MockRasterCache::AddMockLayer(), flutter::testing::MockRasterCache::AddMockPicture(), flutter::DlPathBuilder::AddOval(), flutter::DlPathBuilder::AddRect(), flutter::DlSkCanvasAdapter::ClipOval(), flutter::DlSkCanvasDispatcher::clipOval(), flutter::DlSkCanvasAdapter::ClipRect(), flutter::DlSkCanvasDispatcher::clipRect(), flutter::RasterCacheResult::draw(), flutter::DlSkCanvasDispatcher::drawArc(), flutter::DlSkCanvasAdapter::DrawArc(), flutter::DlSkCanvasAdapter::DrawAtlas(), flutter::DlSkCanvasDispatcher::drawAtlas(), flutter::DlSkCanvasDispatcher::drawDisplayList(), flutter::DlSkCanvasAdapter::DrawDisplayList(), flutter::DlSkCanvasAdapter::DrawImageNine(), flutter::DlSkCanvasDispatcher::drawImageNine(), flutter::DlSkCanvasAdapter::DrawImageRect(), flutter::DlSkCanvasDispatcher::drawImageRect(), flutter::DlSkCanvasDispatcher::drawOval(), flutter::DlSkCanvasAdapter::DrawOval(), flutter::DlSkCanvasDispatcher::drawRect(), flutter::DlSkCanvasAdapter::DrawRect(), flutter::LayerRasterCacheItem::GetPaintBoundsFromLayer(), IsDisplayListWorthRasterizing(), flutter::DlPath::IsOval(), flutter::DlPath::IsRect(), flutter::DlPath::MakeArc(), flutter::DlPath::MakeOval(), flutter::testing::SkJobRenderer::MakePicture(), flutter::DlPath::MakeRect(), flutter::DlPath::MakeRoundRectXY(), flutter::DlSkCanvasAdapter::QuickReject(), flutter::testing::CanvasCompareTester::RenderWithClips(), flutter::testing::CanvasCompareTester::RenderWithSaveRestore(), flutter::DlSkCanvasDispatcher::saveLayer(), flutter::DlSkCanvasAdapter::SaveLayer(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::DisplayListNopTest::test_mode_color_via_rendering(), ToSkRect(), ToSkRRect(), and flutter::DisplayListRasterCacheItem::TryToPrepareRasterCache().

ToSkRect() [2/4]

const SkRect * flutter::ToSkRect ( const DlRect *  rect )

inline

Definition at line 103 of file dl_geometry_conversions.h.

                                                  {
  return rect == nullptr ? nullptr : reinterpret_cast<const SkRect*>(rect);
}

ToSkRect() [3/4]

const SkRect * flutter::ToSkRect ( const std::optional< DlRect > &  rect )

inline

Definition at line 107 of file dl_geometry_conversions.h.

                                                               {
  return rect.has_value() ? &ToSkRect(rect.value()) : nullptr;
}

References ToSkRect().

ToSkRect() [4/4]

SkRect * flutter::ToSkRect ( DlRect *  rect )

inline

Definition at line 111 of file dl_geometry_conversions.h.

                                      {
  return rect == nullptr ? nullptr : reinterpret_cast<SkRect*>(rect);
}

ToSkRects()

const SkRect * flutter::ToSkRects ( const DlRect *  rects )

inline

Definition at line 115 of file dl_geometry_conversions.h.

                                                    {
  return rects == nullptr ? nullptr : reinterpret_cast<const SkRect*>(rects);
}

ToSkRRect()

const SkRRect flutter::ToSkRRect ( const DlRoundRect &  round_rect )

inline

Definition at line 135 of file dl_geometry_conversions.h.

                                                              {
  SkVector radii[4];
  radii[SkRRect::kUpperLeft_Corner] =
      ToSkVector(round_rect.GetRadii().top_left);
  radii[SkRRect::kUpperRight_Corner] =
      ToSkVector(round_rect.GetRadii().top_right);
  radii[SkRRect::kLowerLeft_Corner] =
      ToSkVector(round_rect.GetRadii().bottom_left);
  radii[SkRRect::kLowerRight_Corner] =
      ToSkVector(round_rect.GetRadii().bottom_right);
  SkRRect rrect;
  rrect.setRectRadii(ToSkRect(round_rect.GetBounds()), radii);
  return rrect;
};

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, ToSkRect(), and ToSkVector().

Referenced by flutter::DlPathBuilder::AddRoundRect(), flutter::CanvasPath::addRRect(), flutter::DlSkCanvasAdapter::ClipRoundRect(), flutter::DlSkCanvasDispatcher::clipRoundRect(), flutter::DlSkCanvasDispatcher::drawDiffRoundRect(), flutter::DlSkCanvasAdapter::DrawDiffRoundRect(), flutter::DlSkCanvasDispatcher::drawRoundRect(), flutter::DlSkCanvasAdapter::DrawRoundRect(), flutter::DlPath::MakeRoundRect(), flutter::testing::CanvasCompareTester::RenderWithClips(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and ToApproximateSkRRect().

ToSkSize()

const SkSize & flutter::ToSkSize ( const DlSize &  size )

inline

Definition at line 123 of file dl_geometry_conversions.h.

                                                  {
  return *reinterpret_cast<const SkSize*>(&size);
}

References size.

Referenced by flutter_runner::ExternalViewEmbedder::SubmitFlutterView().

ToSkVector()

const SkVector & flutter::ToSkVector ( const DlSize &  size )

inline

Definition at line 131 of file dl_geometry_conversions.h.

                                                      {
  return *reinterpret_cast<const SkVector*>(&size);
}

References size.

Referenced by flutter::testing::TEST(), and ToSkRRect().

ToStrokedSk()

SkPaint flutter::ToStrokedSk

(

const DlPaint &

paint

)

Definition at line 61 of file dl_sk_conversions.cc.

                                          {
  DlPaint stroked_paint = paint;
  stroked_paint.setDrawStyle(DlDrawStyle::kStroke);
  return ToSk(stroked_paint);
}

References kStroke, flutter::DlPaint::setDrawStyle(), and ToSk().

Referenced by flutter::DlSkCanvasAdapter::DrawDashedLine(), flutter::DlSkCanvasAdapter::DrawLine(), flutter::DlSkCanvasAdapter::DrawPoints(), and flutter::testing::TEST().

TransformedSurfaceSize()

static DlISize flutter::TransformedSurfaceSize ( const DlISize &  size, const DlMatrix &  transformation  )

static

Definition at line 19 of file embedder_external_view.cc.

                                                                      {
  const auto source_rect = DlRect::MakeSize(size);
  const auto transformed_rect =
      source_rect.TransformAndClipBounds(transformation);
  return DlIRect::RoundOut(transformed_rect).GetSize();
}

References impeller::TRect< Scalar >::MakeSize(), impeller::TRect< T >::RoundOut(), and size.

UnblockSIGPROF()

static void flutter::UnblockSIGPROF ( )

static

Definition at line 335 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)
}

References set.

Referenced by RunTester().

UndeadChar()

uint32_t flutter::UndeadChar ( uint32_t  ch )

inline

Definition at line 34 of file keyboard_utils.h.

                                        {
  return ch & ~kDeadKeyCharMask;
}

Referenced by flutter::KeyboardKeyChannelHandler::KeyboardHook().

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 564 of file platform_view_android_jni_impl.cc.

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

References ANDROID_SHELL_HOLDER, and texture_id.

Referenced by RegisterApi().

UpdateDisplayMetrics()

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

static

Definition at line 411 of file platform_view_android_jni_impl.cc.

                                                     {
  ANDROID_SHELL_HOLDER->UpdateDisplayMetrics();
}

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

UpdateJavaAssetManager()

static void flutter::UpdateJavaAssetManager ( JNIEnv *  env, jobject  obj, jlong  shell_holder, jobject  jAssetManager, jstring  jAssetBundlePath  )

static

Definition at line 698 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);
}

References ANDROID_SHELL_HOLDER, fml::jni::JavaStringToString(), and flutter::AssetResolver::kApkAssetProvider.

Referenced by RegisterApi().

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

References FML_DCHECK, FML_LOG, image, queue, fml::tracing::TraceFlow::Step(), and TRACE_EVENT0.

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

References FML_LOG.

WCharBufferToString()

std::string flutter::WCharBufferToString

(

const wchar_t *

wstr

)

Convert a null terminated wchar_t buffer to a std::string using Windows utilities.

The reliance on wchar_t buffers is problematic on C++20 since their interop with standard library components has been deprecated/removed.

Parameters

[in]

wstr

The null terminated buffer.

Returns

The converted string if conversion is possible. Empty string otherwise.

Definition at line 11 of file wchar_util.cc.

                                                   {
  if (!wstr) {
    return "";
  }
 
  int buffer_size = WideCharToMultiByte(CP_UTF8,  //
                                        0,        //
                                        wstr,     //
                                        -1,       //
                                        nullptr,  //
                                        0,        //
                                        nullptr,  //
                                        nullptr   //
  );
  if (buffer_size <= 0) {
    return "";
  }
 
  std::string result(buffer_size - 1, 0);
  WideCharToMultiByte(CP_UTF8,        //
                      0,              //
                      wstr,           //
                      -1,             //
                      result.data(),  //
                      buffer_size,    //
                      nullptr,        //
                      nullptr         //
  );
  return result;
}

Referenced by flutter::DirectManipulationOwner::Update().

WindowsPlatformThreadPrioritySetter()

static void flutter::WindowsPlatformThreadPrioritySetter ( FlutterThreadPriority  priority )

static

Definition at line 62 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;
    }
  }
}

References kBackground, kDisplay, kNormal, and kRaster.

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

WrapOnscreenSurface()

static sk_sp< SkSurface > flutter::WrapOnscreenSurface ( GrDirectContext *  context, const DlISize &  size, intptr_t  fbo  )

static

Definition at line 132 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
  );
}

References color_type, FirstSupportedColorType(), format, and size.

WriteServerErrorResponse()

static void flutter::WriteServerErrorResponse ( rapidjson::Document *  document, const char *  message  )

static

Definition at line 99 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());
}

References message.

Variable Documentation

backends

it will be possible to load the file into Perfetto s trace viewer use test 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 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 258 of file switch_defs.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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring flutter::buffer

Definition at line 98 of file switch_defs.h.

Referenced by flutter::DartIsolateGroupData::AddKernelBuffer(), flutter::FlutterSkiaVulkanMemoryAllocator::allocateBufferMemory(), flutter::AndroidShellHolder::AndroidShellHolder(), flutter::BuiltinSkiaCodecImageGenerator::BuiltinSkiaCodecImageGenerator(), flutter::ByteBufferStreamWriter::ByteBufferStreamWriter(), flutter::ImageEncodingImpeller::ConvertDlImageToSkImage(), ConvertMappingToNSData(), flutter::ImageGeneratorRegistry::CreateCompatibleGenerator(), flutter::ImageDecoderImpeller::DecompressTexture(), flutter::PlatformConfiguration::DispatchPointerDataPacket(), DispatchPointerDataPacket(), flutter::gpu::RenderPass::Draw(), flutter::JsonMessageCodec::EncodeMessageInternal(), flutter::PlatformViewAndroidJNIImpl::FlutterViewUpdateSemantics(), GetBitmap(), GetCursorFromBuffer(), GetExecutableDirectory(), impeller::testing::GetImageMemoryBarriers(), flutter::testing::FuchsiaShellTest::GetLocalTime(), GetPreferredLanguages(), GetPreferredLanguagesFromMUI(), GetUserTimeFormat(), flutter::ImageGeneratorRegistry::ImageGeneratorRegistry(), flutter::ImmutableBuffer::init(), flutter::ImmutableBuffer::initFromAsset(), flutter::ImmutableBuffer::initFromFile(), flutter::testing::MemsetPatternSetOrCheck(), flutter::testing::MemsetPatternSetOrCheck(), flutter::DartIsolate::PrepareForRunningFromKernel(), flutter::ByteBufferStreamReader::ReadBytes(), impeller::testing::RendererDartTest::RenderDartToPlayground(), flutter::PlatformConfigurationNativeApi::RespondToPlatformMessage(), impeller::testing::RecordingRenderPass::SetVertexBuffer(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), flutter::PlatformViewAndroidDelegate::UpdateSemantics(), and flutter::ImageDecoderImpeller::UploadTextureToPrivate().

counts

it will be possible to load the file into Perfetto s trace viewer use test 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 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 221 of file switch_defs.h.

dart

it will be possible to load the file into Perfetto s trace viewer use test 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 disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via flutter::dart

Definition at line 197 of file switch_defs.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.

Referenced by FindAndInvokeDartPluginRegistrant(), flutter::testing::DartIsolateTest::OverrideDartPluginRegistrant(), and flutter::testing::DartIsolateTest::TearDown().

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 36 of file switch_defs.h.

Referenced by _glGetIntegerv(), flutter::AccessibilityBridge::AccessibilityBridge(), flutter::FlutterPlatformNodeDelegate::AccessibilityPerformAction(), BM_PlatformMessageResponseDartComplete(), flutter::PersistentCache::BuildCacheObject(), flutter::testing::CheckTextSkData(), impeller::testing::CompareFunctionUI(), flutter::PlatformMessageResponseDart::Complete(), flutter::PlatformMessageResponseDartPort::Complete(), flutter::PlatformConfiguration::CompletePlatformMessageResponse(), ConvertNSDataToMappingPtr(), CopyNSDataToMapping(), flutter::testing::CreateSimpleSimulatedPointerData(), flutter::testing::CreateSimulatedMousePointerData(), flutter::testing::CreateSimulatedPointerData(), flutter::testing::CreateSimulatedPointerData(), flutter::testing::CreateSimulatedTrackpadGestureData(), Data(), flutter::MessageCodec< T >::DecodeMessage(), flutter::MethodCodec< T >::DecodeMethodCall(), DeserializeImageWithoutData(), DestroyData(), flutter::DlPath::Dispatch(), flutter::AccessibilityBridgeMac::DispatchAccessibilityAction(), flutter::AccessibilityBridgeWindows::DispatchAccessibilityAction(), DispatchPointerDataPacket(), flutter::PersistentCache::DumpSkp(), flutter::EmbedderSurfaceVulkanImpeller::EmbedderSurfaceVulkanImpeller(), EncodeImage(), flutter::EngineMethodResult< T >::ErrorInternal(), flutter::PlatformViewAndroidJNIImpl::FlutterViewHandlePlatformMessageResponse(), flutter::HostWindow::GetOwnedWindows(), flutter::PlatformMessageHandlerIos::HandlePlatformMessage(), flutter::FragmentProgram::initFromAsset(), flutter::FlutterProjectBundle::LoadAotData(), flutter::testing::LoadValidImageFixture(), flutter::gpu::ShaderLibrary::MakeFromAsset(), flutter::BuiltinSkiaCodecImageGenerator::MakeFromData(), flutter::FlutterSkiaVulkanMemoryAllocator::mapMemory(), flutter::testing::MockEmbedderApiForKeyboard(), impeller::testing::mockReadPixels(), flutter::testing::NormalizeImage(), flutter::DirectManipulationEventHandler::OnContentUpdated(), flutter::testing::OpenFixtureAsSkData(), flutter::gpu::Texture::Overwrite(), FlutterStandardReaderWriter::readerWithData:, flutter::SomeDataExtensionSerializer::ReadValueOfType(), flutter::PlatformConfiguration::ReportTimings(), flutter::PlatformConfigurationNativeApi::RespondToPlatformMessage(), flutter::BinaryMessengerImpl::Send(), flutter::internal::ReplyManager::SendResponseData(), flutter::SurfaceFrame::set_user_data(), flutter::RuntimeController::SetInitialLifecycleState(), flutter::RuntimeController::SetUserSettingsData(), flutter::WindowsProcTable::SetWindowCompositionAttribute(), flutter::testing::DlSurfaceProvider::Snapshot(), flutter::EngineMethodResult< T >::SuccessInternal(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), TEST(), TEST(), TEST(), TEST(), flutter::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), flutter::egl::ProcTable::TexImage2D(), ToSk(), flutter::testing::WriteImageToDisk(), and FlutterStandardWriter::writeValue:.

flow_type [1/2]

const auto* flutter::flow_type = "RasterCacheFlow::DisplayList"

static

Definition at line 145 of file display_list_raster_cache_item.cc.

Referenced by flutter::DisplayListRasterCacheItem::TryToPrepareRasterCache(), and flutter::LayerRasterCacheItem::TryToPrepareRasterCache().

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 use test 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 disable asset flutter::fonts

Definition at line 188 of file switch_defs.h.

forever

it will be possible to load the file into Perfetto s trace viewer use test 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 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 209 of file switch_defs.h.

full

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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring meaning that once it is flutter::full

Definition at line 98 of file switch_defs.h.

g_acquire_latest_image_method

jmethodID flutter::g_acquire_latest_image_method = nullptr

static

Definition at line 135 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::ImageProducerTextureEntryAcquireLatestImage(), and flutter::PlatformViewAndroid::Register().

g_async_wait_for_vsync_method_

jmethodID flutter::g_async_wait_for_vsync_method_ = nullptr

static

Definition at line 20 of file vsync_waiter_android.cc.

Referenced by flutter::VsyncWaiterAndroid::Register().

g_attach_to_gl_context_method

jmethodID flutter::g_attach_to_gl_context_method = nullptr

static

Definition at line 125 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), and flutter::PlatformViewAndroidJNIImpl::SurfaceTextureAttachToGLContext().

g_bitmap_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_bitmap_class = nullptr

static

Definition at line 55 of file platform_view_android_jni_impl.cc.

Referenced by GetBitmap(), and RegisterApi().

g_bitmap_config_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_bitmap_config_class = nullptr

static

Definition at line 57 of file platform_view_android_jni_impl.cc.

Referenced by GetBitmap(), and RegisterApi().

g_bitmap_config_value_of

jmethodID flutter::g_bitmap_config_value_of = nullptr

static

Definition at line 157 of file platform_view_android_jni_impl.cc.

Referenced by GetBitmap(), and RegisterApi().

g_bitmap_copy_pixels_from_buffer_method

jmethodID flutter::g_bitmap_copy_pixels_from_buffer_method = nullptr

static

Definition at line 155 of file platform_view_android_jni_impl.cc.

Referenced by GetBitmap(), and RegisterApi().

g_bitmap_create_bitmap_method

jmethodID flutter::g_bitmap_create_bitmap_method = nullptr

static

Definition at line 153 of file platform_view_android_jni_impl.cc.

Referenced by GetBitmap(), and RegisterApi().

g_compute_platform_resolved_locale_method

jmethodID flutter::g_compute_platform_resolved_locale_method = nullptr

static

Definition at line 143 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::FlutterViewComputePlatformResolvedLocale(), and flutter::PlatformViewAndroid::Register().

g_decode_image_method

jmethodID flutter::g_decode_image_method = nullptr

static

Definition at line 20 of file android_image_generator.cc.

Referenced by flutter::AndroidImageGenerator::Register().

g_detach_from_gl_context_method

jmethodID flutter::g_detach_from_gl_context_method = nullptr

static

Definition at line 133 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), and flutter::PlatformViewAndroidJNIImpl::SurfaceTextureDetachFromGLContext().

g_flutter_callback_info_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_flutter_callback_info_class

static

Initial value:

=
    nullptr

Definition at line 36 of file platform_view_android_jni_impl.cc.

Referenced by LookupCallbackInformation(), and flutter::PlatformViewAndroid::Register().

g_flutter_callback_info_constructor

jmethodID flutter::g_flutter_callback_info_constructor = nullptr

static

Definition at line 61 of file platform_view_android_jni_impl.cc.

Referenced by LookupCallbackInformation(), and flutter::PlatformViewAndroid::Register().

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.

Referenced by flutter::AndroidImageGenerator::Register(), flutter::PlatformViewAndroid::Register(), RegisterApi(), and SpawnJNI().

g_flutter_jni_class [2/2]

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_flutter_jni_class = nullptr

static

Definition at line 39 of file platform_view_android_jni_impl.cc.

g_flutter_main

std::unique_ptr<FlutterMain> flutter::g_flutter_main

static

Definition at line 73 of file flutter_main.cc.

Referenced by flutter::FlutterMain::Get().

g_get_transform_matrix_method

jmethodID flutter::g_get_transform_matrix_method = nullptr

static

Definition at line 131 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), and flutter::PlatformViewAndroidJNIImpl::SurfaceTextureGetTransformMatrix().

g_hardware_buffer_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_hardware_buffer_class = nullptr

static

Definition at line 51 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_hardware_buffer_close_method

jmethodID flutter::g_hardware_buffer_close_method = nullptr

static

Definition at line 141 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::HardwareBufferClose(), and flutter::PlatformViewAndroid::Register().

g_image_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_image_class = nullptr

static

Definition at line 49 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_image_close_method

jmethodID flutter::g_image_close_method = nullptr

static

Definition at line 139 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::ImageClose(), and flutter::PlatformViewAndroid::Register().

g_image_consumer_texture_registry_interface

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_image_consumer_texture_registry_interface = nullptr

static

Definition at line 47 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_image_get_hardware_buffer_method

jmethodID flutter::g_image_get_hardware_buffer_method = nullptr

static

Definition at line 137 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::ImageGetHardwareBuffer(), and flutter::PlatformViewAndroid::Register().

g_java_long_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_java_long_class = nullptr

static

Definition at line 53 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), RegisterApi(), and SpawnJNI().

g_java_weak_reference_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_java_weak_reference_class

static

Initial value:

=
    nullptr

Definition at line 41 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_java_weak_reference_get_method

jmethodID flutter::g_java_weak_reference_get_method = nullptr

static

Definition at line 123 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::ImageProducerTextureEntryAcquireLatestImage(), flutter::PlatformViewAndroid::Register(), flutter::PlatformViewAndroidJNIImpl::SurfaceTextureAttachToGLContext(), flutter::PlatformViewAndroidJNIImpl::SurfaceTextureDetachFromGLContext(), flutter::PlatformViewAndroidJNIImpl::SurfaceTextureGetTransformMatrix(), flutter::PlatformViewAndroidJNIImpl::SurfaceTextureShouldUpdate(), and flutter::PlatformViewAndroidJNIImpl::SurfaceTextureUpdateTexImage().

g_jni_constructor

jmethodID flutter::g_jni_constructor = nullptr

static

Definition at line 117 of file platform_view_android_jni_impl.cc.

Referenced by RegisterApi(), and SpawnJNI().

g_jni_shell_holder_field

jfieldID flutter::g_jni_shell_holder_field = nullptr

static

Definition at line 63 of file platform_view_android_jni_impl.cc.

Referenced by RegisterApi(), and SpawnJNI().

g_long_constructor

jmethodID flutter::g_long_constructor = nullptr

static

Definition at line 119 of file platform_view_android_jni_impl.cc.

Referenced by RegisterApi(), and SpawnJNI().

g_mutators_stack_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_mutators_stack_class = nullptr

static

Definition at line 160 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::FlutterViewOnDisplayPlatformView(), flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_mutators_stack_init_method

jmethodID flutter::g_mutators_stack_init_method = nullptr

static

Definition at line 161 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::FlutterViewOnDisplayPlatformView(), flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_mutators_stack_push_clippath_method

jmethodID flutter::g_mutators_stack_push_clippath_method = nullptr

static

Definition at line 166 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_mutators_stack_push_cliprect_method

jmethodID flutter::g_mutators_stack_push_cliprect_method = nullptr

static

Definition at line 163 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::FlutterViewOnDisplayPlatformView(), flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_mutators_stack_push_cliprrect_method

jmethodID flutter::g_mutators_stack_push_cliprrect_method = nullptr

static

Definition at line 164 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::FlutterViewOnDisplayPlatformView(), flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_mutators_stack_push_opacity_method

jmethodID flutter::g_mutators_stack_push_opacity_method = nullptr

static

Definition at line 165 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_mutators_stack_push_transform_method

jmethodID flutter::g_mutators_stack_push_transform_method = nullptr

static

Definition at line 162 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::FlutterViewOnDisplayPlatformView(), flutter::PlatformViewAndroidJNIImpl::onDisplayPlatformView2(), and flutter::PlatformViewAndroid::Register().

g_overlay_surface_id_method

jmethodID flutter::g_overlay_surface_id_method = nullptr

static

Definition at line 149 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::createOverlaySurface2(), flutter::PlatformViewAndroidJNIImpl::FlutterViewCreateOverlaySurface(), and RegisterApi().

g_overlay_surface_surface_method

jmethodID flutter::g_overlay_surface_surface_method = nullptr

static

Definition at line 151 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroidJNIImpl::createOverlaySurface2(), flutter::PlatformViewAndroidJNIImpl::FlutterViewCreateOverlaySurface(), and RegisterApi().

g_path_fill_type_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_path_fill_type_class = nullptr

static

Definition at line 179 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_path_fill_type_even_odd_field

jfieldID flutter::g_path_fill_type_even_odd_field = nullptr

static

Definition at line 181 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_path_fill_type_winding_field

jfieldID flutter::g_path_fill_type_winding_field = nullptr

static

Definition at line 180 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_refresh_rate_

std::atomic_uint flutter::g_refresh_rate_ = 60

static

Definition at line 21 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 145 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), and flutter::PlatformViewAndroidJNIImpl::RequestDartDeferredLibrary().

g_shell

absl::NoDestructor<std::unique_ptr<Shell> > flutter::g_shell

static

Definition at line 124 of file tester_main.cc.

Referenced by RunTester(), and Spawn().

g_surface_texture_wrapper_should_update

jmethodID flutter::g_surface_texture_wrapper_should_update = nullptr

static

Definition at line 127 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), and flutter::PlatformViewAndroidJNIImpl::SurfaceTextureShouldUpdate().

g_texture_wrapper_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_texture_wrapper_class = nullptr

static

Definition at line 44 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

g_update_tex_image_method

jmethodID flutter::g_update_tex_image_method = nullptr

static

Definition at line 129 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register(), and flutter::PlatformViewAndroidJNIImpl::SurfaceTextureUpdateTexImage().

g_vsync_waiter_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::g_vsync_waiter_class = nullptr

static

Definition at line 19 of file vsync_waiter_android.cc.

Referenced by flutter::VsyncWaiterAndroid::Register().

gc

it will be possible to load the file into Perfetto s trace viewer use test 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 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 220 of file switch_defs.h.

gFontFile

std::string flutter::gFontFile

static

Definition at line 10 of file flow_test_utils.cc.

Referenced by GetFontFile(), and SetFontFile().

gGoldenDir

std::string flutter::gGoldenDir

static

Definition at line 9 of file flow_test_utils.cc.

Referenced by GetGoldenDir(), and SetGoldenDir().

gVM

std::weak_ptr<DartVM> flutter::gVM

static

Definition at line 16 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create(), and flutter::DartVMRef::IsInstanceRunning().

gVMData

std::weak_ptr<const DartVMData> flutter::gVMData

static

Definition at line 25 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create(), and flutter::DartVMRef::GetVMData().

gVMDependentsMutex

std::mutex flutter::gVMDependentsMutex

static

Definition at line 24 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create(), flutter::DartVMRef::GetIsolateNameServer(), flutter::DartVMRef::GetServiceProtocol(), and flutter::DartVMRef::GetVMData().

gVMIsolateNameServer

std::weak_ptr<IsolateNameServer> flutter::gVMIsolateNameServer

static

Definition at line 27 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create(), and flutter::DartVMRef::GetIsolateNameServer().

gVMLaunchCount

std::atomic_size_t flutter::gVMLaunchCount

static

Definition at line 261 of file dart_vm.cc.

Referenced by flutter::DartVM::GetVMLaunchCount().

gVMLeak

std::shared_ptr<DartVM>* flutter::gVMLeak

static

Definition at line 17 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create().

gVMMutex

std::mutex flutter::gVMMutex

static

Definition at line 15 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create(), flutter::DartVMRef::IsInstanceRunning(), and flutter::DartVMRef::~DartVMRef().

gVMServiceProtocol

std::weak_ptr<ServiceProtocol> flutter::gVMServiceProtocol

static

Definition at line 26 of file dart_vm_lifecycle.cc.

Referenced by flutter::DartVMRef::Create(), and flutter::DartVMRef::GetServiceProtocol().

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 54 of file switch_defs.h.

Referenced by flutter::ImpellerAllocator::allocPixelRef(), flutter::testing::DisplayListNopTest::get_output(), flutter::testing::DlSurfaceProvider::MakeInfo(), flutter::testing::MakeTestDisplayList(), flutter::testing::MakeTestImage(), flutter::testing::MakeTestImage(), flutter::testing::MockTexture::MakeTestTexture(), flutter::testing::EmbedderTestContextMetal::PopulateExternalTexture(), flutter::testing::CanvasCompareTester::quickCompareToReference(), impeller::testing::TEST(), flutter::testing::DisplayListNopTest::test_attributes_image(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

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 69 of file switch_defs.h.

Referenced by flutter::EmbedderThreadHost::CreateEmbedderOrEngineManagedThreadHost(), and flutter::FlutterWindowsEngine::Run().

impeller

it will be possible to load the file into Perfetto s trace viewer use test 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 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 248 of file switch_defs.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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode flutter::ipv6

Definition at line 86 of file switch_defs.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 23 of file engine.cc.

kBinarySearchThreshold

const int flutter::kBinarySearchThreshold = 10

Definition at line 13 of file dl_region.cc.

Referenced by flutter::DlRegion::intersects().

kBlendModeDefault

constexpr uint32_t flutter::kBlendModeDefault

constexpr

Initial value:

=
    static_cast<uint32_t>(SkBlendMode::kSrcOver)

Definition at line 53 of file paint.cc.

Referenced by flutter::Paint::paint().

kBlendModeIndex

constexpr int flutter::kBlendModeIndex = 6

constexpr

Definition at line 31 of file paint.cc.

Referenced by flutter::Paint::paint().

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.

Referenced by flutter::DartCallbackCache::SetCachePath().

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.

Referenced by flutter::DartCallbackCache::LoadCacheFromDisk().

kColorAlphaIndex

constexpr int flutter::kColorAlphaIndex = 4

constexpr

Definition at line 29 of file paint.cc.

kColorBlueIndex

constexpr int flutter::kColorBlueIndex = 3

constexpr

Definition at line 28 of file paint.cc.

kColorFilterIndex

constexpr int flutter::kColorFilterIndex = 1

constexpr

Definition at line 48 of file paint.cc.

Referenced by flutter::Paint::paint().

kColorGreenIndex

constexpr int flutter::kColorGreenIndex = 2

constexpr

Definition at line 27 of file paint.cc.

kColorRedIndex

constexpr int flutter::kColorRedIndex = 1

constexpr

Definition at line 26 of file paint.cc.

kColorSpaceIndex

constexpr int flutter::kColorSpaceIndex = 5

constexpr

Definition at line 30 of file paint.cc.

kControl

constexpr int flutter::kControl = 1 << 3

constexpr

Definition at line 15 of file keyboard_utils.h.

Referenced by flutter::FlutterWindow::HandleMessage(), flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded(), flutter::testing::TEST(), and flutter::testing::TEST().

kDartAllConfigsArgs

const char* flutter::kDartAllConfigsArgs[]

static

Initial value:

= {
    
    "--enable_mirrors=false",
    "--background_compilation",
    
    
    
}

Definition at line 34 of file dart_vm.cc.

                                           {
    // clang-format off
    "--enable_mirrors=false",
    "--background_compilation",
    // 'mark_when_idle' appears to cause a regression, turning off for now.
    // "--mark_when_idle",
    // clang-format on
};

kDartAssertArgs

const char* flutter::kDartAssertArgs[]

static

Initial value:

= {
    
    "--enable_asserts",
    
}

Definition at line 65 of file dart_vm.cc.

                                       {
    // clang-format off
    "--enable_asserts",
    // clang-format on
};

kDartDefaultTraceStreamsArgs

const char* flutter::kDartDefaultTraceStreamsArgs[]

static

Initial value:

{
    "--timeline_streams=Dart,Embedder,GC,Microtask",
}

Definition at line 94 of file dart_vm.cc.

                                                 {
    "--timeline_streams=Dart,Embedder,GC,Microtask",
};

kDartDisableIntegerDivisionArgs

const char* flutter::kDartDisableIntegerDivisionArgs[]

static

Initial value:

= {
    "--no_use_integer_division",
}

Definition at line 61 of file dart_vm.cc.

                                                       {
    "--no_use_integer_division",
};

kDartEndlessTraceBufferArgs

const char* flutter::kDartEndlessTraceBufferArgs[]

static

Initial value:

{
    "--timeline_recorder=endless",
}

Definition at line 75 of file dart_vm.cc.

                                                {
    "--timeline_recorder=endless",
};

kDartPrecompilationArgs

const char* flutter::kDartPrecompilationArgs[] = {"--precompilation"}

static

Definition at line 43 of file dart_vm.cc.

{"--precompilation"};

kDartProfileMicrotasksArgs

const char* flutter::kDartProfileMicrotasksArgs[]

static

Initial value:

{
    "--profile_microtasks",
}

Definition at line 108 of file dart_vm.cc.

                                               {
    "--profile_microtasks",
};

kDartStartPausedArgs

const char* flutter::kDartStartPausedArgs[]

static

Initial value:

{
    "--pause_isolates_on_start",
}

Definition at line 71 of file dart_vm.cc.

                                         {
    "--pause_isolates_on_start",
};

kDartStartupTraceStreamsArgs

const char* flutter::kDartStartupTraceStreamsArgs[]

static

Initial value:

{
    "--timeline_streams=Compiler,Dart,Debugger,Embedder,GC,Isolate,Microtask,"
    "VM,API",
}

Definition at line 98 of file dart_vm.cc.

                                                 {
    "--timeline_streams=Compiler,Dart,Debugger,Embedder,GC,Isolate,Microtask,"
    "VM,API",
};

kDartSystraceTraceBufferArgs

const char* flutter::kDartSystraceTraceBufferArgs[]

static

Initial value:

= {
    "--timeline_recorder=systrace",
}

Definition at line 79 of file dart_vm.cc.

                                                    {
    "--timeline_recorder=systrace",
};

kDartSystraceTraceStreamsArgs

const char* flutter::kDartSystraceTraceStreamsArgs[]

static

Initial value:

= {
    "--timeline_streams=Compiler,Dart,Debugger,Embedder,GC,Isolate,Microtask,"
    "VM,API",
}

Definition at line 103 of file dart_vm.cc.

                                                     {
    "--timeline_streams=Compiler,Dart,Debugger,Embedder,GC,Isolate,Microtask,"
    "VM,API",
};

kDartWrapperInfoUIImage

const tonic::DartWrapperInfo flutter::kDartWrapperInfoUIImage("ui", "_Image") ( "ui"  , "_Image"    )

static

kDartWriteProtectCodeArgs

const char* flutter::kDartWriteProtectCodeArgs[]

static

Initial value:

= {
    "--no_write_protect_code",
}

Definition at line 56 of file dart_vm.cc.

                                                 {
    "--no_write_protect_code",
};

kDataByteCount

constexpr size_t flutter::kDataByteCount = 68

constexpr

Definition at line 42 of file paint.cc.

Referenced by flutter::Paint::paint().

kDeadKeyCharMask

constexpr int flutter::kDeadKeyCharMask = 0x80000000

constexpr

Definition at line 30 of file keyboard_utils.h.

Referenced by flutter::KeyboardManager::HandleMessage().

kDefaultDpi

constexpr UINT flutter::kDefaultDpi = 96

constexpr

Definition at line 12 of file dpi_utils.h.

kDisplayEngineStatistics

const int flutter::kDisplayEngineStatistics = 1 << 2

Definition at line 20 of file performance_overlay_layer.h.

Referenced by flutter::PerformanceOverlayLayer::Paint().

kDisplayRasterizerStatistics

const int flutter::kDisplayRasterizerStatistics = 1 << 0

Definition at line 18 of file performance_overlay_layer.h.

Referenced by flutter::PerformanceOverlayLayer::Paint(), and flutter::testing::TEST_F().

kEhCloseEnough

constexpr DlScalar flutter::kEhCloseEnough = impeller::kEhCloseEnough

staticconstexpr

Definition at line 36 of file dl_geometry_types.h.

Referenced by flutter::testing::MATCHER_P(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), and impeller::testing::TEST_P().

kEmpty [1/2]

constexpr DlRect flutter::kEmpty = DlRect()

staticconstexpr

Definition at line 122 of file dl_builder.cc.

Referenced by ProtectEmpty().

kEmpty [2/2]

constexpr DlRect flutter::kEmpty = DlRect()

staticconstexpr

Definition at line 13 of file dl_matrix_clip_tracker.cc.

kExitTypeNames

constexpr const char* flutter::kExitTypeNames[]

staticconstexpr

Initial value:

= {
    PlatformHandler::kExitTypeRequired, PlatformHandler::kExitTypeCancelable}

Definition at line 405 of file platform_handler.cc.

                                                {
    PlatformHandler::kExitTypeRequired, PlatformHandler::kExitTypeCancelable};

Referenced by flutter::PlatformHandler::RequestAppExit().

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.

                                           {
  @0x00000024 : @0x0010000000d,  // Enter -> enter
  @0x00000030 : @0x00100000009,  // Tab -> tab
  @0x00000033 : @0x00100000008,  // Backspace -> backspace
  @0x00000035 : @0x0010000001b,  // Escape -> escape
  @0x00000036 : @0x00200000107,  // MetaRight -> metaRight
  @0x00000037 : @0x00200000106,  // MetaLeft -> metaLeft
  @0x00000038 : @0x00200000102,  // ShiftLeft -> shiftLeft
  @0x00000039 : @0x00100000104,  // CapsLock -> capsLock
  @0x0000003a : @0x00200000104,  // AltLeft -> altLeft
  @0x0000003b : @0x00200000100,  // ControlLeft -> controlLeft
  @0x0000003c : @0x00200000103,  // ShiftRight -> shiftRight
  @0x0000003d : @0x00200000105,  // AltRight -> altRight
  @0x0000003e : @0x00200000101,  // ControlRight -> controlRight
  @0x0000003f : @0x00100000106,  // Fn -> fn
  @0x00000040 : @0x00100000811,  // F17 -> f17
  @0x00000041 : @0x0020000022e,  // NumpadDecimal -> numpadDecimal
  @0x00000043 : @0x0020000022a,  // NumpadMultiply -> numpadMultiply
  @0x00000045 : @0x0020000022b,  // NumpadAdd -> numpadAdd
  @0x00000047 : @0x0010000010a,  // NumLock -> numLock
  @0x00000048 : @0x00100000a10,  // AudioVolumeUp -> audioVolumeUp
  @0x00000049 : @0x00100000a0f,  // AudioVolumeDown -> audioVolumeDown
  @0x0000004a : @0x00100000a11,  // AudioVolumeMute -> audioVolumeMute
  @0x0000004b : @0x0020000022f,  // NumpadDivide -> numpadDivide
  @0x0000004c : @0x0020000020d,  // NumpadEnter -> numpadEnter
  @0x0000004e : @0x0020000022d,  // NumpadSubtract -> numpadSubtract
  @0x0000004f : @0x00100000812,  // F18 -> f18
  @0x00000050 : @0x00100000813,  // F19 -> f19
  @0x00000051 : @0x0020000023d,  // NumpadEqual -> numpadEqual
  @0x00000052 : @0x00200000230,  // Numpad0 -> numpad0
  @0x00000053 : @0x00200000231,  // Numpad1 -> numpad1
  @0x00000054 : @0x00200000232,  // Numpad2 -> numpad2
  @0x00000055 : @0x00200000233,  // Numpad3 -> numpad3
  @0x00000056 : @0x00200000234,  // Numpad4 -> numpad4
  @0x00000057 : @0x00200000235,  // Numpad5 -> numpad5
  @0x00000058 : @0x00200000236,  // Numpad6 -> numpad6
  @0x00000059 : @0x00200000237,  // Numpad7 -> numpad7
  @0x0000005a : @0x00100000814,  // F20 -> f20
  @0x0000005b : @0x00200000238,  // Numpad8 -> numpad8
  @0x0000005c : @0x00200000239,  // Numpad9 -> numpad9
  @0x0000005d : @0x00200000022,  // IntlYen -> intlYen
  @0x0000005e : @0x00200000021,  // IntlRo -> intlRo
  @0x0000005f : @0x0020000022c,  // NumpadComma -> numpadComma
  @0x00000060 : @0x00100000805,  // F5 -> f5
  @0x00000061 : @0x00100000806,  // F6 -> f6
  @0x00000062 : @0x00100000807,  // F7 -> f7
  @0x00000063 : @0x00100000803,  // F3 -> f3
  @0x00000064 : @0x00100000808,  // F8 -> f8
  @0x00000065 : @0x00100000809,  // F9 -> f9
  @0x00000066 : @0x00200000011,  // Lang2 -> lang2
  @0x00000067 : @0x0010000080b,  // F11 -> f11
  @0x00000068 : @0x00200000010,  // Lang1 -> lang1
  @0x00000069 : @0x0010000080d,  // F13 -> f13
  @0x0000006a : @0x00100000810,  // F16 -> f16
  @0x0000006b : @0x0010000080e,  // F14 -> f14
  @0x0000006d : @0x0010000080a,  // F10 -> f10
  @0x0000006e : @0x00100000505,  // ContextMenu -> contextMenu
  @0x0000006f : @0x0010000080c,  // F12 -> f12
  @0x00000071 : @0x0010000080f,  // F15 -> f15
  @0x00000072 : @0x00100000407,  // Insert -> insert
  @0x00000073 : @0x00100000306,  // Home -> home
  @0x00000074 : @0x00100000308,  // PageUp -> pageUp
  @0x00000075 : @0x0010000007f,  // Delete -> delete
  @0x00000076 : @0x00100000804,  // F4 -> f4
  @0x00000077 : @0x00100000305,  // End -> end
  @0x00000078 : @0x00100000802,  // F2 -> f2
  @0x00000079 : @0x00100000307,  // PageDown -> pageDown
  @0x0000007a : @0x00100000801,  // F1 -> f1
  @0x0000007b : @0x00100000302,  // ArrowLeft -> arrowLeft
  @0x0000007c : @0x00100000303,  // ArrowRight -> arrowRight
  @0x0000007d : @0x00100000301,  // ArrowDown -> arrowDown
  @0x0000007e : @0x00100000304,  // ArrowUp -> arrowUp
};

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.

                                             {
  @0x00000038 : @(kModifierFlagShiftLeft),
  @0x0000003c : @(kModifierFlagShiftRight),
  @0x0000003b : @(kModifierFlagControlLeft),
  @0x0000003e : @(kModifierFlagControlRight),
  @0x0000003a : @(kModifierFlagAltLeft),
  @0x0000003d : @(kModifierFlagAltRight),
  @0x00000037 : @(kModifierFlagMetaLeft),
  @0x00000036 : @(kModifierFlagMetaRight),
};

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.

                                            {
  @0x00000000 : @0x00070004,  // keyA
  @0x00000001 : @0x00070016,  // keyS
  @0x00000002 : @0x00070007,  // keyD
  @0x00000003 : @0x00070009,  // keyF
  @0x00000004 : @0x0007000b,  // keyH
  @0x00000005 : @0x0007000a,  // keyG
  @0x00000006 : @0x0007001d,  // keyZ
  @0x00000007 : @0x0007001b,  // keyX
  @0x00000008 : @0x00070006,  // keyC
  @0x00000009 : @0x00070019,  // keyV
  @0x0000000a : @0x00070064,  // intlBackslash
  @0x0000000b : @0x00070005,  // keyB
  @0x0000000c : @0x00070014,  // keyQ
  @0x0000000d : @0x0007001a,  // keyW
  @0x0000000e : @0x00070008,  // keyE
  @0x0000000f : @0x00070015,  // keyR
  @0x00000010 : @0x0007001c,  // keyY
  @0x00000011 : @0x00070017,  // keyT
  @0x00000012 : @0x0007001e,  // digit1
  @0x00000013 : @0x0007001f,  // digit2
  @0x00000014 : @0x00070020,  // digit3
  @0x00000015 : @0x00070021,  // digit4
  @0x00000016 : @0x00070023,  // digit6
  @0x00000017 : @0x00070022,  // digit5
  @0x00000018 : @0x0007002e,  // equal
  @0x00000019 : @0x00070026,  // digit9
  @0x0000001a : @0x00070024,  // digit7
  @0x0000001b : @0x0007002d,  // minus
  @0x0000001c : @0x00070025,  // digit8
  @0x0000001d : @0x00070027,  // digit0
  @0x0000001e : @0x00070030,  // bracketRight
  @0x0000001f : @0x00070012,  // keyO
  @0x00000020 : @0x00070018,  // keyU
  @0x00000021 : @0x0007002f,  // bracketLeft
  @0x00000022 : @0x0007000c,  // keyI
  @0x00000023 : @0x00070013,  // keyP
  @0x00000024 : @0x00070028,  // enter
  @0x00000025 : @0x0007000f,  // keyL
  @0x00000026 : @0x0007000d,  // keyJ
  @0x00000027 : @0x00070034,  // quote
  @0x00000028 : @0x0007000e,  // keyK
  @0x00000029 : @0x00070033,  // semicolon
  @0x0000002a : @0x00070031,  // backslash
  @0x0000002b : @0x00070036,  // comma
  @0x0000002c : @0x00070038,  // slash
  @0x0000002d : @0x00070011,  // keyN
  @0x0000002e : @0x00070010,  // keyM
  @0x0000002f : @0x00070037,  // period
  @0x00000030 : @0x0007002b,  // tab
  @0x00000031 : @0x0007002c,  // space
  @0x00000032 : @0x00070035,  // backquote
  @0x00000033 : @0x0007002a,  // backspace
  @0x00000035 : @0x00070029,  // escape
  @0x00000036 : @0x000700e7,  // metaRight
  @0x00000037 : @0x000700e3,  // metaLeft
  @0x00000038 : @0x000700e1,  // shiftLeft
  @0x00000039 : @0x00070039,  // capsLock
  @0x0000003a : @0x000700e2,  // altLeft
  @0x0000003b : @0x000700e0,  // controlLeft
  @0x0000003c : @0x000700e5,  // shiftRight
  @0x0000003d : @0x000700e6,  // altRight
  @0x0000003e : @0x000700e4,  // controlRight
  @0x0000003f : @0x00000012,  // fn
  @0x00000040 : @0x0007006c,  // f17
  @0x00000041 : @0x00070063,  // numpadDecimal
  @0x00000043 : @0x00070055,  // numpadMultiply
  @0x00000045 : @0x00070057,  // numpadAdd
  @0x00000047 : @0x00070053,  // numLock
  @0x00000048 : @0x00070080,  // audioVolumeUp
  @0x00000049 : @0x00070081,  // audioVolumeDown
  @0x0000004a : @0x0007007f,  // audioVolumeMute
  @0x0000004b : @0x00070054,  // numpadDivide
  @0x0000004c : @0x00070058,  // numpadEnter
  @0x0000004e : @0x00070056,  // numpadSubtract
  @0x0000004f : @0x0007006d,  // f18
  @0x00000050 : @0x0007006e,  // f19
  @0x00000051 : @0x00070067,  // numpadEqual
  @0x00000052 : @0x00070062,  // numpad0
  @0x00000053 : @0x00070059,  // numpad1
  @0x00000054 : @0x0007005a,  // numpad2
  @0x00000055 : @0x0007005b,  // numpad3
  @0x00000056 : @0x0007005c,  // numpad4
  @0x00000057 : @0x0007005d,  // numpad5
  @0x00000058 : @0x0007005e,  // numpad6
  @0x00000059 : @0x0007005f,  // numpad7
  @0x0000005a : @0x0007006f,  // f20
  @0x0000005b : @0x00070060,  // numpad8
  @0x0000005c : @0x00070061,  // numpad9
  @0x0000005d : @0x00070089,  // intlYen
  @0x0000005e : @0x00070087,  // intlRo
  @0x0000005f : @0x00070085,  // numpadComma
  @0x00000060 : @0x0007003e,  // f5
  @0x00000061 : @0x0007003f,  // f6
  @0x00000062 : @0x00070040,  // f7
  @0x00000063 : @0x0007003c,  // f3
  @0x00000064 : @0x00070041,  // f8
  @0x00000065 : @0x00070042,  // f9
  @0x00000066 : @0x00070091,  // lang2
  @0x00000067 : @0x00070044,  // f11
  @0x00000068 : @0x00070090,  // lang1
  @0x00000069 : @0x00070068,  // f13
  @0x0000006a : @0x0007006b,  // f16
  @0x0000006b : @0x00070069,  // f14
  @0x0000006d : @0x00070043,  // f10
  @0x0000006e : @0x00070065,  // contextMenu
  @0x0000006f : @0x00070045,  // f12
  @0x00000071 : @0x0007006a,  // f15
  @0x00000072 : @0x00070049,  // insert
  @0x00000073 : @0x0007004a,  // home
  @0x00000074 : @0x0007004b,  // pageUp
  @0x00000075 : @0x0007004c,  // delete
  @0x00000076 : @0x0007003d,  // f4
  @0x00000077 : @0x0007004d,  // end
  @0x00000078 : @0x0007003b,  // f2
  @0x00000079 : @0x0007004e,  // pageDown
  @0x0000007a : @0x0007003a,  // f1
  @0x0000007b : @0x00070050,  // arrowLeft
  @0x0000007c : @0x0007004f,  // arrowRight
  @0x0000007d : @0x00070051,  // arrowDown
  @0x0000007e : @0x00070052,  // arrowUp
};

kFileUriPrefix

constexpr char flutter::kFileUriPrefix[] = "file://"

constexpr

Definition at line 118 of file dart_vm.cc.

Referenced by DartFileModifiedCallback().

kFileUriPrefixLength

constexpr size_t flutter::kFileUriPrefixLength = sizeof(kFileUriPrefix) - 1

constexpr

Definition at line 119 of file dart_vm.cc.

Referenced by DartFileModifiedCallback().

kFilterQualities

const std::array<DlImageSampling, 4> flutter::kFilterQualities

static

Initial value:

= {
    DlImageSampling::kNearestNeighbor,
    DlImageSampling::kLinear,
    DlImageSampling::kMipmapLinear,
    DlImageSampling::kCubic,
}

Definition at line 29 of file image_filter.cc.

                                                             {
    DlImageSampling::kNearestNeighbor,
    DlImageSampling::kLinear,
    DlImageSampling::kMipmapLinear,
    DlImageSampling::kCubic,
};

Referenced by flutter::ImageFilter::SamplingFromIndex().

kFilterQualityIndex

constexpr int flutter::kFilterQualityIndex = 12

constexpr

Definition at line 37 of file paint.cc.

Referenced by flutter::Paint::paint().

kFlutterImplicitViewId

constexpr int64_t flutter::kFlutterImplicitViewId = 0

constexpr

Definition at line 35 of file constants.h.

Referenced by fl_engine_set_implicit_view(), fl_view_new(), flutter::DartUI::InitForIsolate(), realize_cb(), flutter::PlatformConfiguration::RemoveView(), flutter::Rasterizer::ScreenshotLastLayerTree(), SendPointerEventWithData(), SendWindowMetrics(), flutter::testing::EmbedderConfigBuilder::SetCompositor(), SetViewportMetrics(), flutter_runner::ExternalViewEmbedder::SubmitFlutterView(), flutter::AndroidExternalViewEmbedder::SubmitFlutterView(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), TEST_F(), TEST_F(), TEST_F(), and flutter::testing::TEST_F().

kFlutterThreadName

constexpr const char* flutter::kFlutterThreadName = "io.flutter"

constexpr

Definition at line 126 of file embedder_thread_host.cc.

Referenced by MakeThreadConfig().

kFontChange

constexpr char flutter::kFontChange[] = "fontsChange"

constexpr

Definition at line 54 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 DlRect flutter::kGiantRect = DlRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F)

staticconstexpr

Definition at line 40 of file layer.h.

Referenced by flutter::testing::LayerTestBase< BaseT >::LayerTestBase(), flutter::CompositorContext::ScopedFrame::Raster(), flutter::LayerStateStack::set_preroll_delegate(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

kGrCacheMaxByteSize

const size_t flutter::kGrCacheMaxByteSize = 24 * (1 << 20)

static

Definition at line 40 of file gpu_surface_gl_skia.cc.

Referenced by flutter::GPUSurfaceGLSkia::MakeGLContext().

kHandleKey

const char* flutter::kHandleKey = "handle"

static

Definition at line 25 of file callback_cache.cc.

Referenced by flutter::DartCallbackCache::LoadCacheFromDisk().

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

constexpr int flutter::kHorizontalScrollSemanticsActions

constexpr

Initial value:

=
    static_cast<int32_t>(SemanticsAction::kScrollLeft) |
    static_cast<int32_t>(SemanticsAction::kScrollRight)

Definition at line 56 of file semantics_node.h.

kImageFilterIndex

constexpr int flutter::kImageFilterIndex = 2

constexpr

Definition at line 49 of file paint.cc.

Referenced by flutter::Paint::paint().

kImageReaderSwapchainSize

constexpr size_t flutter::kImageReaderSwapchainSize = 6u

staticconstexpr

Definition at line 20 of file image_lru.h.

Referenced by flutter::ImageLRU::AddImage(), flutter::ImageLRU::Clear(), flutter::ImageLRU::FindImage(), flutter::testing::TEST(), and flutter::testing::TEST().

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 210 of file compositor_context.cc.

kImplicitViewId

static constexpr int64_t flutter::kImplicitViewId = 0

constexpr

Definition at line 56 of file flutter_windows_engine.h.

Referenced by ConfigureShell(), flutter::PlatformViewAndroid::DispatchSemanticsAction(), FlutterDesktopPluginRegistrarGetView(), flutter::FlutterWindowsView::IsImplicitView(), flutter::EngineModifier::SetImplicitView(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

kInvertColorIndex

constexpr int flutter::kInvertColorIndex = 16

constexpr

Definition at line 41 of file paint.cc.

Referenced by flutter::Paint::paint().

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 19 of file dl_sk_conversions.cc.

                                         {
  -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
};

Referenced by ToSk().

kIsAntiAliasIndex

constexpr int flutter::kIsAntiAliasIndex = 0

constexpr

Definition at line 25 of file paint.cc.

Referenced by flutter::Paint::paint().

kIsolateChannel

constexpr char flutter::kIsolateChannel[] = "flutter/isolate"

staticconstexpr

Definition at line 28 of file engine.cc.

Referenced by flutter::Engine::Run().

kKeyCodeControlLeft

constexpr int flutter::kKeyCodeControlLeft = 0xa2

constexpr

Definition at line 21 of file keyboard_utils.h.

Referenced by flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded().

kKeyCodeShiftLeft

constexpr int flutter::kKeyCodeShiftLeft = 0xa0

constexpr

Definition at line 18 of file keyboard_utils.h.

Referenced by flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded().

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.

                                           {
    LayoutGoal{0x31, 0x20, false},         // Space
    LayoutGoal{0x27, 0x22, false},         // Quote
    LayoutGoal{0x2b, 0x2c, false},         // Comma
    LayoutGoal{0x1b, 0x2d, false},         // Minus
    LayoutGoal{0x2f, 0x2e, false},         // Period
    LayoutGoal{0x2c, 0x2f, false},         // Slash
    LayoutGoal{0x1d, 0x30, true},          // Digit0
    LayoutGoal{0x12, 0x31, true},          // Digit1
    LayoutGoal{0x13, 0x32, true},          // Digit2
    LayoutGoal{0x14, 0x33, true},          // Digit3
    LayoutGoal{0x15, 0x34, true},          // Digit4
    LayoutGoal{0x17, 0x35, true},          // Digit5
    LayoutGoal{0x16, 0x36, true},          // Digit6
    LayoutGoal{0x1a, 0x37, true},          // Digit7
    LayoutGoal{0x1c, 0x38, true},          // Digit8
    LayoutGoal{0x19, 0x39, true},          // Digit9
    LayoutGoal{0x29, 0x3b, false},         // Semicolon
    LayoutGoal{0x18, 0x3d, false},         // Equal
    LayoutGoal{0x21, 0x5b, false},         // BracketLeft
    LayoutGoal{0x2a, 0x5c, false},         // Backslash
    LayoutGoal{0x1e, 0x5d, false},         // BracketRight
    LayoutGoal{0x32, 0x60, false},         // Backquote
    LayoutGoal{0x00, 0x61, true},          // KeyA
    LayoutGoal{0x0b, 0x62, true},          // KeyB
    LayoutGoal{0x08, 0x63, true},          // KeyC
    LayoutGoal{0x02, 0x64, true},          // KeyD
    LayoutGoal{0x0e, 0x65, true},          // KeyE
    LayoutGoal{0x03, 0x66, true},          // KeyF
    LayoutGoal{0x05, 0x67, true},          // KeyG
    LayoutGoal{0x04, 0x68, true},          // KeyH
    LayoutGoal{0x22, 0x69, true},          // KeyI
    LayoutGoal{0x26, 0x6a, true},          // KeyJ
    LayoutGoal{0x28, 0x6b, true},          // KeyK
    LayoutGoal{0x25, 0x6c, true},          // KeyL
    LayoutGoal{0x2e, 0x6d, true},          // KeyM
    LayoutGoal{0x2d, 0x6e, true},          // KeyN
    LayoutGoal{0x1f, 0x6f, true},          // KeyO
    LayoutGoal{0x23, 0x70, true},          // KeyP
    LayoutGoal{0x0c, 0x71, true},          // KeyQ
    LayoutGoal{0x0f, 0x72, true},          // KeyR
    LayoutGoal{0x01, 0x73, true},          // KeyS
    LayoutGoal{0x11, 0x74, true},          // KeyT
    LayoutGoal{0x20, 0x75, true},          // KeyU
    LayoutGoal{0x09, 0x76, true},          // KeyV
    LayoutGoal{0x0d, 0x77, true},          // KeyW
    LayoutGoal{0x07, 0x78, true},          // KeyX
    LayoutGoal{0x10, 0x79, true},          // KeyY
    LayoutGoal{0x06, 0x7a, true},          // KeyZ
    LayoutGoal{0x0a, 0x200000020, false},  // IntlBackslash
};

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

kLibraryPathKey

const char* flutter::kLibraryPathKey = "library_path"

static

Definition at line 29 of file callback_cache.cc.

Referenced by flutter::DartCallbackCache::LoadCacheFromDisk().

kLifecycleChannel

constexpr char flutter::kLifecycleChannel[] = "flutter/lifecycle"

staticconstexpr

Definition at line 24 of file engine.cc.

Referenced by flutter::Engine::DispatchPlatformMessage().

kListViewsExtensionName

constexpr std::string_view flutter::kListViewsExtensionName

staticconstexpr

Initial value:

=
    "_flutter.listViews"

Definition at line 44 of file service_protocol.cc.

Referenced by flutter::ServiceProtocol::ServiceProtocol().

kLocalizationChannel

constexpr char flutter::kLocalizationChannel[] = "flutter/localization"

staticconstexpr

Definition at line 26 of file engine.cc.

Referenced by flutter::Engine::DispatchPlatformMessage().

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 = 14

constexpr

Definition at line 39 of file paint.cc.

Referenced by flutter::Paint::paint().

kMaskFilterIndex

constexpr int flutter::kMaskFilterIndex = 13

constexpr

Definition at line 38 of file paint.cc.

Referenced by flutter::Paint::paint().

kMaskFilterSigmaIndex

constexpr int flutter::kMaskFilterSigmaIndex = 15

constexpr

Definition at line 40 of file paint.cc.

Referenced by flutter::Paint::paint().

kMaxCount

constexpr size_t flutter::kMaxCount = 4

staticconstexpr

Definition at line 269 of file dart_vm.cc.

kMaxFrameMarkers

const size_t flutter::kMaxFrameMarkers = 8

static

Definition at line 19 of file stopwatch_dl.cc.

Referenced by flutter::DlStopwatchVisualizer::Visualize().

kMaxSamples

const size_t flutter::kMaxSamples = 120

static

Definition at line 18 of file stopwatch_dl.cc.

Referenced by flutter::DlStopwatchVisualizer::Visualize().

kMegaByteSizeInBytes

constexpr double flutter::kMegaByteSizeInBytes = (1 << 20)

constexpr

Definition at line 9 of file constants.h.

Referenced by FlutterDartProject::defaultBundleIdentifier.

kMinCount

constexpr size_t flutter::kMinCount = 2

staticconstexpr

Definition at line 268 of file dart_vm.cc.

kMinimumAndroidApiLevelForImpeller

constexpr int flutter::kMinimumAndroidApiLevelForImpeller = 29

constexpr

Definition at line 34 of file flutter_main.cc.

Referenced by flutter::FlutterMain::SelectedRenderingAPI().

kMinPlatformViewId

constexpr int32_t flutter::kMinPlatformViewId = -1

constexpr

Definition at line 11 of file semantics_node.cc.

Referenced by flutter::SemanticsNode::IsPlatformViewNode().

kNameKey

const char* flutter::kNameKey = "name"

static

Definition at line 27 of file callback_cache.cc.

Referenced by flutter::DartCallbackCache::LoadCacheFromDisk().

kNavigationChannel

constexpr char flutter::kNavigationChannel[] = "flutter/navigation"

staticconstexpr

Definition at line 25 of file engine.cc.

Referenced by flutter::Engine::DispatchPlatformMessage().

kObjectCount

constexpr int flutter::kObjectCount = 3

constexpr

Definition at line 50 of file paint.cc.

Referenced by flutter::Paint::paint().

kOpaqueBlack

constexpr int flutter::kOpaqueBlack = 0xff000000

constexpr

Definition at line 12 of file compositor_software.cc.

Referenced by flutter::CompositorSoftware::Present().

kOrientationUpdateNotificationKey

const char *const flutter::kOrientationUpdateNotificationKey

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOrientationNotificationKey"

Definition at line 39 of file FlutterPlatformPlugin.mm.

kOrientationUpdateNotificationName

const char *const flutter::kOrientationUpdateNotificationName

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOrientationNotificationName"

Definition at line 37 of file FlutterPlatformPlugin.mm.

kOverlayStyleUpdateNotificationKey

const char *const flutter::kOverlayStyleUpdateNotificationKey

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOverlayNotificationKey"

Definition at line 43 of file FlutterPlatformPlugin.mm.

kOverlayStyleUpdateNotificationName

const char *const flutter::kOverlayStyleUpdateNotificationName

Initial value:

=
    "io.flutter.plugin.platform.SystemChromeOverlayNotificationName"

Definition at line 41 of file FlutterPlatformPlugin.mm.

kPi

constexpr DlScalar flutter::kPi = impeller::kPi

staticconstexpr

Definition at line 37 of file dl_geometry_types.h.

Referenced by impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), and impeller::testing::TEST_P().

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.

kPollTimeoutTimerId

const uintptr_t flutter::kPollTimeoutTimerId = 1

static

Definition at line 16 of file task_runner_window.cc.

Referenced by flutter::TaskRunnerWindow::PollOnce().

kRepresentationKey

const char* flutter::kRepresentationKey = "representation"

static

Definition at line 26 of file callback_cache.cc.

Referenced by flutter::DartCallbackCache::LoadCacheFromDisk().

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.

Referenced by flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded(), flutter::testing::TEST(), and flutter::testing::TEST().

kScanCodeControlRight

constexpr int flutter::kScanCodeControlRight = 0xe01d

constexpr

Definition at line 20 of file keyboard_utils.h.

Referenced by flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded(), flutter::testing::TEST(), and flutter::testing::TEST().

kScanCodeShiftLeft

constexpr int flutter::kScanCodeShiftLeft = 0x2a

constexpr

Definition at line 16 of file keyboard_utils.h.

Referenced by flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

kScanCodeShiftRight

constexpr int flutter::kScanCodeShiftRight = 0x36

constexpr

Definition at line 17 of file keyboard_utils.h.

Referenced by flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST_F().

kScrollableSemanticsActions

constexpr int flutter::kScrollableSemanticsActions

constexpr

Initial value:

=
    kVerticalScrollSemanticsActions | kHorizontalScrollSemanticsActions

Definition at line 60 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 45 of file dart_vm.cc.

                                     {
    // clang-format off
    "--concurrent_mark=false",
    "--concurrent_sweep=false",
    "--compactor_tasks=1",
    "--scavenger_tasks=0",
    "--marker_tasks=0",
    // clang-format on
};

kSettingsChannel

constexpr char flutter::kSettingsChannel[] = "flutter/settings"

staticconstexpr

Definition at line 27 of file engine.cc.

Referenced by flutter::Engine::DispatchPlatformMessage().

kShaderIndex

constexpr int flutter::kShaderIndex = 0

constexpr

Definition at line 47 of file paint.cc.

Referenced by flutter::Paint::paint().

kShift

constexpr int flutter::kShift = 1 << 0

constexpr

Definition at line 14 of file keyboard_utils.h.

Referenced by flutter::FlutterWindow::HandleMessage(), flutter::KeyboardKeyEmbedderHandler::SyncModifiersIfNeeded(), flutter::testing::TEST(), and flutter::testing::TEST().

kSizeFactorSmall

const double flutter::kSizeFactorSmall = 0.3

Definition at line 324 of file dl_region_benchmarks.cc.

kSkiaChannel

constexpr char flutter::kSkiaChannel[] = "flutter/skia"

constexpr

Definition at line 51 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.

                                                  {
    // clang-format off
    0, 4, 12,
    1, 5, 13,
    3, 7, 15,
    // clang-format on
};

Referenced by ToMatrix4(), and ToSkMatrix().

kStderrStreamId

const char flutter::kStderrStreamId[] = "Stderr"

static

Definition at line 155 of file dart_vm.cc.

Referenced by ServiceStreamCancelCallback(), and ServiceStreamListenCallback().

kStdoutStreamId

const char flutter::kStdoutStreamId[] = "Stdout"

static

Definition at line 154 of file dart_vm.cc.

Referenced by ServiceStreamCancelCallback(), and ServiceStreamListenCallback().

kStrokeCapIndex

constexpr int flutter::kStrokeCapIndex = 9

constexpr

Definition at line 34 of file paint.cc.

Referenced by flutter::Paint::paint().

kStrokeJoinIndex

constexpr int flutter::kStrokeJoinIndex = 10

constexpr

Definition at line 35 of file paint.cc.

Referenced by flutter::Paint::paint().

kStrokeMiterLimitDefault

constexpr float flutter::kStrokeMiterLimitDefault = 4.0f

constexpr

Definition at line 58 of file paint.cc.

Referenced by flutter::Paint::paint().

kStrokeMiterLimitIndex

constexpr int flutter::kStrokeMiterLimitIndex = 11

constexpr

Definition at line 36 of file paint.cc.

Referenced by flutter::Paint::paint().

kStrokeWidthIndex

constexpr int flutter::kStrokeWidthIndex = 8

constexpr

Definition at line 33 of file paint.cc.

Referenced by flutter::Paint::paint().

kStyleIndex

constexpr int flutter::kStyleIndex = 7

constexpr

Definition at line 32 of file paint.cc.

Referenced by flutter::Paint::paint().

kSystemActions

constexpr int flutter::kSystemActions

constexpr

Initial value:

=
    static_cast<int32_t>(SemanticsAction::kDidGainAccessibilityFocus) |
    static_cast<int32_t>(SemanticsAction::kDidLoseAccessibilityFocus)

The following actions are not user-initiated.

Definition at line 64 of file semantics_node.h.

kSystemChannel

constexpr char flutter::kSystemChannel[] = "flutter/system"

constexpr

Definition at line 52 of file shell.cc.

kTypeKey

constexpr char flutter::kTypeKey[] = "type"

constexpr

Definition at line 53 of file shell.cc.

Referenced by flutter::KeyEventHandler::KeyboardHook(), and flutter::KeyboardKeyChannelHandler::KeyboardHook().

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.

Referenced by flutter::PlatformViewAndroidJNIImpl::GetDisplayRefreshRate(), and flutter::DisplayManager::GetMainDisplayRefreshRate().

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

constexpr int flutter::kVerticalScrollSemanticsActions

constexpr

Initial value:

=
    static_cast<int32_t>(SemanticsAction::kScrollUp) |
    static_cast<int32_t>(SemanticsAction::kScrollDown)

Definition at line 52 of file semantics_node.h.

kViewIdPrefx

constexpr std::string_view flutter::kViewIdPrefx = "_flutterView/"

staticconstexpr

Definition at line 43 of file service_protocol.cc.

Referenced by CreateFlutterViewID().

kVisualizeEngineStatistics

const int flutter::kVisualizeEngineStatistics = 1 << 3

Definition at line 21 of file performance_overlay_layer.h.

Referenced by flutter::PerformanceOverlayLayer::Paint().

kVisualizeRasterizerStatistics

const int flutter::kVisualizeRasterizerStatistics = 1 << 1

Definition at line 19 of file performance_overlay_layer.h.

Referenced by flutter::PerformanceOverlayLayer::Paint(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

kVsyncFlowName

constexpr const char* flutter::kVsyncFlowName = "VsyncFlow"

staticconstexpr

Definition at line 17 of file vsync_waiter.cc.

Referenced by flutter::VsyncWaiter::FireCallback().

kVsyncTraceName

constexpr const char* flutter::kVsyncTraceName = "VsyncProcessCallback"

staticconstexpr

Definition at line 19 of file vsync_waiter.cc.

Referenced by flutter::VsyncWaiter::FireCallback().

manager

it will be possible to load the file into Perfetto s trace viewer use test 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 disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font flutter::manager

Definition at line 200 of file switch_defs.h.

Referenced by flutter::egl::Manager::Create(), flutter::EngineModifier::SetPlatformViewPlugin(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), TEST(), TEST(), TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::WaitUntilUpdated().

mode

it will be possible to load the file into Perfetto s trace viewer use test 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 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 210 of file switch_defs.h.

Referenced by flutter::testing::BM_DrawPoints(), flutter::testing::BM_DrawVertices(), flutter::DrawAtlasOp::dispatch(), flutter::DrawAtlasCulledOp::dispatch(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DlSkCanvasAdapter::DrawAtlas(), flutter::testing::DisplayListStreamDispatcher::drawAtlas(), flutter::DlSkCanvasDispatcher::drawAtlas(), flutter::DrawAtlasBaseOp::DrawAtlasBaseOp(), flutter::DrawAtlasCulledOp::DrawAtlasCulledOp(), flutter::DrawAtlasOp::DrawAtlasOp(), flutter::DisplayListBuilder::DrawColor(), flutter::DlSkCanvasAdapter::DrawColor(), flutter::DlSkCanvasDispatcher::drawColor(), flutter::testing::DisplayListStreamDispatcher::drawColor(), flutter::testing::DisplayListStreamDispatcher::drawPoints(), flutter::testing::DisplayListGeneralReceiver::drawPoints(), flutter::DlSkCanvasDispatcher::drawPoints(), flutter::DisplayListBuilder::DrawPoints(), flutter::DlSkCanvasAdapter::DrawPoints(), flutter::DlSkCanvasDispatcher::drawVertices(), flutter::testing::DisplayListStreamDispatcher::drawVertices(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlSkCanvasAdapter::DrawVertices(), flutter::ImageFilter::filter(), flutter::testing::FilterModeToString(), impeller::testing::GetBlendModeSelection(), flutter::testing::GetTestVertices(), flutter::DlColorFilter::MakeBlend(), flutter::testing::PointModeToString(), flutter::PlatformConfigurationNativeApi::RequestDartPerformanceMode(), flutter::testing::SaveLayerExpectations::SaveLayerExpectations(), flutter::DlPaint::setBlendMode(), flutter::DlSkPaintDispatchHelper::setBlendMode(), flutter::testing::DisplayListStreamDispatcher::setBlendMode(), SetTextureLayout(), flutter::testing::TEST(), impeller::testing::TEST(), flutter::testing::DisplayListNopTest::test_attributes_image(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::DisplayListNopTest::test_mode_color_via_filter(), flutter::testing::DisplayListNopTest::test_mode_color_via_rendering(), impeller::testing::TEST_P(), ToSk(), ToSk(), and flutter::testing::VertexModeToString().

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.

                                             {
  @(kModifierFlagShiftLeft) : @0x00000038,
  @(kModifierFlagShiftRight) : @0x0000003c,
  @(kModifierFlagControlLeft) : @0x0000003b,
  @(kModifierFlagControlRight) : @0x0000003e,
  @(kModifierFlagAltLeft) : @0x0000003a,
  @(kModifierFlagAltRight) : @0x0000003d,
  @(kModifierFlagMetaLeft) : @0x00000037,
  @(kModifierFlagMetaRight) : @0x00000036,
};

name

DEF_SWITCHES_START aot vmservice shared library flutter::name

Definition at line 27 of file switch_defs.h.

Referenced by impeller::testing::GoldenDigest::AddDimension(), flutter::testing::DartFixture::AddFfiNativeCallback(), flutter::testing::TestDartNativeResolver::AddFfiNativeCallback(), flutter::testing::EmbedderTestContext::AddNativeCallback(), flutter::testing::DartFixture::AddNativeCallback(), flutter::testing::TestDartNativeResolver::AddNativeCallback(), flutter::testing::WindowsTestContext::AddNativeFunction(), flutter::FlutterEventTracer::addTraceEvent(), flutter::testing::DisplayListTestBase< BaseT >::Build(), flutter::testing::TestGLOnscreenOnlySurface::CreateGrContext(), flutter::testing::ThreadTest::CreateNewThread(), flutter::PlatformViewAndroid::DispatchEmptyPlatformMessage(), flutter::PlatformViewAndroid::DispatchPlatformMessage(), flutter::testing::EmbedderTestContextGL::EmbedderTestContextGL(), flutter::JsonMethodCodec::EncodeMethodCallInternal(), flutter::testing::FixtureNameForBackend(), impeller::testing::GetBlendModeSelection(), flutter::DartCallbackCache::GetCallbackHandle(), flutter::DartRuntimeHooks::GetCallbackHandle(), flutter::FlutterEventTracer::getCategoryGroupEnabled(), flutter::gpu::Shader::UniformBinding::GetMemberMetadata(), flutter::testing::TestGLOnscreenOnlySurface::GetProcAddress(), flutter::AssetManagerFontStyleSet::getStyle(), txt::TypefaceFontStyleSet::getStyle(), flutter::gpu::Shader::GetUniformStruct(), flutter::gpu::Shader::GetUniformTexture(), flutter::testing::EmbedderTestContextGL::GLGetProcAddress(), flutter::testing::EmbedderTestContextVulkan::InstanceProcAddr(), InternalFlutterGpu_Shader_GetUniformStructSize(), InvokeFunction(), LookupEntryPoint(), flutter::IsolateNameServer::LookupIsolatePortByName(), flutter::IsolateNameServerNatives::LookupPortByName(), flutter::gpu::ShaderLibrary::MakeFromAsset(), impeller::testing::mockGetIntegerv(), impeller::testing::mockGetString(), impeller::testing::mockGetStringi(), impeller::testing::mockObjectLabelKHR(), flutter::IsolateNameServer::RegisterIsolatePortWithName(), flutter::IsolateNameServerNatives::RegisterPortWithName(), flutter::IsolateNameServer::RemoveIsolateNameMapping(), flutter::IsolateNameServerNatives::RemovePortNameMapping(), flutter::internal::ResizeChannel(), flutter::PlatformConfigurationNativeApi::SendChannelUpdate(), flutter::PlatformConfigurationNativeApi::SendPlatformMessage(), flutter::PlatformConfigurationNativeApi::SendPortPlatformMessage(), flutter::internal::SetChannelWarnsOnOverflow(), flutter::PlatformConfigurationNativeApi::SetIsolateDebugName(), SettingsFromCommandLine(), flutter::testing::ShellTestPlatformViewGL::ShellTestPlatformViewGL(), flutter::testing::SignalHandler::SignalHandler(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), flutter::FlutterEventTracer::updateTraceEventDuration(), flutter::testing::OncePerBackendWarning::warn(), flutter::testing::WriteImageToDisk(), and flutter::AccessibilityBridgeMac::~AccessibilityBridgeMac().

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 52 of file switch_defs.h.

Referenced by flutter::testing::ClipExpector::addExpectation(), flutter::testing::MockRasterCache::AddMockLayer(), flutter::DlPathBuilder::AddPath(), flutter::testing::BM_DrawPath(), flutter::testing::BM_DrawShadow(), flutter::Canvas::clipPath(), flutter::LayerStateStack::MutatorContext::clipPath(), flutter::testing::ClipExpector::clipPath(), flutter::DlSkCanvasAdapter::ClipPath(), flutter::DlSkCanvasDispatcher::clipPath(), flutter::testing::DisplayListStreamDispatcher::clipPath(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListMatrixClipState::clipPath(), flutter::DlCanvasDelegate::clipPath(), flutter::PrerollDelegate::clipPath(), Close(), flutter::DlCanvas::ComputeShadowBounds(), flutter::testing::MyNativeClass::Create(), flutter::CanvasPathMeasure::Create(), CreatePath(), CubicTo(), DartFileModifiedCallback(), DartFileRecorderArgs(), flutter::DartProject::DartProject(), Data(), DestroyPath(), flutter::DlPath::Dispatch(), flutter::Canvas::drawPath(), flutter::DlSkCanvasDispatcher::drawPath(), flutter::testing::DisplayListStreamDispatcher::drawPath(), flutter::DisplayListBuilder::DrawPath(), flutter::DlSkCanvasAdapter::DrawPath(), flutter::Canvas::drawShadow(), flutter::DisplayListBuilder::DrawShadow(), flutter::DlSkCanvasAdapter::DrawShadow(), flutter::DlSkCanvasDispatcher::drawShadow(), flutter::testing::DisplayListStreamDispatcher::drawShadow(), flutter::DlSkCanvasDispatcher::DrawShadow(), GetFileMapping(), GetFillType(), LineTo(), LoadDartDeferredLibrary(), LoadLibraryFromKernel(), flutter::testing::MockLayer::Make(), flutter::DlPath::MakeArc(), flutter::testing::MockLayer::MakeOpacityCompatible(), impeller::testing::MaskBlurVariantTest(), MoveTo(), NativeAssetsDlopen(), NativeAssetsDlopenRelative(), flutter::DlPath::operator+(), flutter::testing::DisplayListStreamDispatcher::out(), flutter::MutatorsStack::PushClipPath(), flutter::SceneBuilder::pushClipPath(), Reset(), flutter::EmbedderResources::ResourceLookup(), SearchMapping(), flutter::PersistentCache::SetCacheDirectoryPath(), flutter::DartCallbackCache::SetCachePath(), flutter::CanvasPathMeasure::setPath(), impeller::testing::WorkingDirectory::SetPath(), SettingsFromCommandLine(), flutter::DlPathBuilder::TakePath(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), flutter::testing::TestPathDispatchClosedTriangle(), flutter::testing::TestPathDispatchConicToQuads(), flutter::testing::TestPathDispatchImplicitMoveAfterClose(), flutter::testing::TestPathDispatchMixedCloseTriangles(), flutter::testing::TestPathDispatchOneOfEachVerb(), flutter::testing::TestPathDispatchUnclosedTriangle(), flutter::DlPath::WithFillType(), flutter::DlPath::WithOffset(), flutter::testing::SkRenderResult::write(), flutter::testing::ImpellerRenderResult::write(), flutter::testing::DlMetalPixelData::write(), and impeller::testing::MetalScreenshot::WriteToPNG().

path_class

fml::jni::ScopedJavaGlobalRef<jclass>* flutter::path_class = nullptr

static

Definition at line 169 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_close_method

jmethodID flutter::path_close_method = nullptr

static

Definition at line 176 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_conic_to_method

jmethodID flutter::path_conic_to_method = nullptr

static

Definition at line 175 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_constructor

jmethodID flutter::path_constructor = nullptr

static

Definition at line 170 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_cubic_to_method

jmethodID flutter::path_cubic_to_method = nullptr

static

Definition at line 174 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_line_to_method

jmethodID flutter::path_line_to_method = nullptr

static

Definition at line 172 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_move_to_method

jmethodID flutter::path_move_to_method = nullptr

static

Definition at line 171 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_quad_to_method

jmethodID flutter::path_quad_to_method = nullptr

static

Definition at line 173 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

path_set_fill_type_method

jmethodID flutter::path_set_fill_type_method = nullptr

static

Definition at line 177 of file platform_view_android_jni_impl.cc.

Referenced by flutter::PlatformViewAndroid::Register().

policy

it will be possible to load the file into Perfetto s trace viewer use test 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 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 230 of file switch_defs.h.

Referenced by flutter::DartProject::set_ui_thread_policy(), and flutter::testing::WindowsConfigBuilder::SetUIThreadPolicy().

rendering

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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not the profiler sample buffer is used as a ring meaning that once it is new samples start overwriting the oldest ones This switch is only meaningful when set in conjunction with enable dart profiling enable software flutter::rendering

Definition at line 108 of file switch_defs.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 disable vm flutter::service

Definition at line 79 of file switch_defs.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 defaults to or::depending on whether ipv6 is specified disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile Make the profiler discard new samples once the profiler sample buffer is full When this flag is not flutter::set

Definition at line 71 of file switch_defs.h.

Referenced by flutter::gpu::ShaderLibrary::MakeFromFlatbuffer(), flutter::ServiceProtocol::ToggleHooks(), and UnblockSIGPROF().

size

it will be possible to load the file into Perfetto s trace viewer use test 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 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 241 of file switch_defs.h.

Referenced by flutter::AndroidSurfaceSoftware::AcquireBackingStore(), flutter::TesterPlatformView::AcquireBackingStore(), flutter::GPUSurfaceGLSkia::AcquireFrame(), flutter::GPUSurfaceSoftware::AcquireFrame(), flutter::EmbedderSurfaceVulkan::AcquireImage(), flutter::EmbedderSurfaceVulkanImpeller::AcquireImage(), flutter::testing::BM_DrawArc(), flutter::testing::BM_DrawImageNine(), flutter::testing::BM_DrawImageRect(), flutter::testing::BM_DrawOval(), flutter::testing::BM_DrawRect(), flutter::PlatformMessageResponseDart::Complete(), ConvertMappingToNSData(), ConvertSize(), flutter::CompositorSoftware::CreateBackingStore(), flutter::FlutterCompositor::CreateBackingStore(), flutter::testing::TestVulkanContext::CreateImage(), flutter::testing::TestMetalContext::CreateMetalTexture(), CreateSnapshotSurface(), flutter::MessageCodec< T >::DecodeMessage(), flutter::MethodCodec< T >::DecodeMethodCall(), FillAllIndices(), flutter::FlutterSkiaVulkanMemoryAllocator::flushMemory(), flutter::DlImageSkia::GetApproximateByteSize(), flutter::DlDeferredImageGPUImpeller::GetApproximateByteSize(), flutter::DlImageGPU::GetApproximateByteSize(), flutter::testing::GetDebuggerStatus(), flutter::DisplayListBuilder::GetImageInfo(), flutter::EmbedderRenderTargetImpeller::GetRenderTargetSize(), flutter::BuiltinSkiaCodecImageGenerator::GetScaledDimensions(), GetSymbolMapping(), flutter::FlutterWindow::InitializeChild(), flutter::FlutterSkiaVulkanMemoryAllocator::invalidateMemory(), flutter::BoxConstraints::IsSatisfiedBy(), flutter::DlDeferredImageGPUImpeller::Make(), flutter::gpu::ShaderLibrary::MakeFromFlatbuffer(), flutter::DlRegion::MakeIntersection(), flutter::SnapshotControllerSkia::MakeRasterSnapshotSync(), flutter::testing::CanvasCompareTester::MakeTextBlob(), impeller::testing::BlendFilterContentsTest::MakeTexture(), impeller::testing::GaussianBlurFilterContentsTest::MakeTexture(), impeller::testing::MatrixFilterContentsTest::MakeTexture(), flutter::DlRegion::MakeUnion(), txt::MatchSystemUIFont(), flutter::testing::MemsetPatternSetOrCheck(), impeller::testing::mockDeleteQueriesEXT(), impeller::testing::mockDeleteTextures(), flutter::testing::NormalizeImage(), flutter::PlatformViewAndroid::NotifyChanged(), flutter::OffscreenSurface::OffscreenSurface(), flutter::FlutterWindow::OnCursorRectUpdated(), flutter::AndroidSurfaceDynamicImpeller::OnScreenSurfaceResize(), flutter::AndroidSurfaceGLSkia::OnScreenSurfaceResize(), flutter::AndroidSurfaceVKImpeller::OnScreenSurfaceResize(), ParseLanguageName(), flutter::PlatformHandler::PlatformHandler(), flutter::StandardCodecSerializer::ReadValueOfType(), flutter::SomeDataExtensionSerializer::ReadValueOfType(), impeller::testing::RectMakeCenterSize(), flutter::testing::ResetAssetManager(), flutter::HostWindow::SetContentSize(), impeller::testing::SetSwapchainImageSize(), flutter::testing::DisplayListRenderingTestBase< BaseT >::TearDownTestSuite(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), TEST(), TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), flutter::testing::TestGLOnscreenOnlySurface::TestGLOnscreenOnlySurface(), ToDlISize(), ToSkISize(), ToSkSize(), ToSkVector(), TransformedSurfaceSize(), flutter::DirectManipulationOwner::Update(), WrapOnscreenSurface(), flutter::StandardCodecSerializer::WriteSize(), and flutter::StandardCodecSerializer::WriteValue().

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 disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set profile flutter::startup

Definition at line 95 of file switch_defs.h.

tracing

it will be possible to load the file into Perfetto s trace viewer use test 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 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 265 of file switch_defs.h.

validation

it will be possible to load the file into Perfetto s trace viewer use test 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 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 256 of file switch_defs.h.