class DisplayCompositor

TODO(https://fxbug.dev/42145655): The `DisplayCompositor` has multiple parts of its code where

usage of the display coordinator is protected by locks, because of the multithreaded

environment of flatland. Ideally, we'd want the `DisplayCompositor` to have sole ownership of

the display coordinator, i.e. it would require a `unique_ptr` instead of a `shared_ptr`.

But since access to the real display coordinator is provided to clients via a `shared_ptr`,

we take in a `shared_ptr` as a parameter here. However, this could cause problems with our

locking mechanisms, as other display-coordinator clients could be accessing the same functions

and/or state at the same time as the `DisplayCompositor` without making use of locks.

`BufferCollectionImporter`

Only called from the main thread.

`BufferCollectionImporter`

Only called from the main thread.

`BufferCollectionImporter`

Called from main thread or Flatland threads.

`BufferCollectionImporter`

Called from main thread or Flatland threads.

Generates frame and presents it to display. This may involve directly scanning out client

images, or it may involve first using the GPU to composite (some of) these images into a single

image which is then scanned out.

`args` can be used to customize behavior in tests. Production code should omit this arg; the

default values are correct for production use cases.

Only called from the main thread.

Notifies the compositor and `ReleaseFenceManager` that a frame was skipped without rendering.

`frame_number` must exceed every frame number previously passed to `RenderFrame()` or

`SkipFrame()`. Only called from the main thread.

Register a new display to the `DisplayCompositor`, which also generates the render targets to

be presented on the display when compositing on the GPU. If `num_render_targets` is 0, this

function will not create any render targets for GPU composition for that display. The buffer

collection info is also returned back to the caller via an output parameter

`num_render_targets` is 0. Otherwise, a valid handle to return the buffer collection data is

required.

TODO(https://fxbug.dev/42137737): We need to figure out exactly how we want the display to

anchor to the Flatland hierarchy. Only called from the main thread.

Values needed to adjust the color of the framebuffer as a postprocessing effect.

Only called from the main thread.

Clamps the minimum value for all channels on all pixels on the display to this number.

Only called from the main thread.

Sets the power mode of `display_id`, synchronously. Returns `ZX_OK`, or one of the

errors of `fuchsia.ui.display.singleton/DisplayPower`:

- `ZX_ERR_NOT_FOUND` if this compositor or the coordinator does not have the display

- `ZX_ERR_NOT_SUPPORTED` if the driver or hardware cannot do `mode`

- `ZX_ERR_INTERNAL` for any other failure.

On `kOff`, frames applied before this call will never be acknowledged by a vsync, so

their release fences are signaled and their frame-presented callbacks invoked now;

then a solid black config is committed, so that the panel shows black rather than the

last frame when it is powered on again. The dropped configs and flushed fences are

shared by all displays.

Only called from the main thread.

False for a display this compositor does not have. Only called from the main

thread.

Runs any pending lazy GPU imports for image layers in `layers`. Used by screenshot /

screen-capture paths that call `Renderer::Render()` directly via `Engine::GetRenderables()`.

Must be called on the main thread (`main_dispatcher_`). Best-effort: if an import fails, the

image stays unimported, is not retried on subsequent calls, and `Renderer::Render()` skips it.

Describes the result of `RenderFrame()`. If it succeeds it is either by showing client images

directly on the display, or by first using the GPU to composite them into a single image.