Thomas Smith

This commit **disables a specific capabilities flag** within the **Graphite rendering backend's `DrawListLayer`** component. This **configuration adjustment** deactivates a particular feature or optimization related to how `DrawListLayer` processes rendering commands. The change is likely a **maintenance step** to address an underlying issue, improve stability, or simplify the rendering pipeline. It will affect **Graphite's** rendering behavior, potentially impacting performance or visual output by modifying the active capabilities of its layer processing.

This commit **introduces and enables forward merging** within the **Graphite rendering backend**, a **new capability** designed to **improve rendering performance**. The core logic, implemented in `src/gpu/graphite/DrawListLayer.cpp` within `recordBackwards` and `recordDraw`, reorders compatible draw calls by pulling earlier draws into newly created layers to enhance pipeline and texture batching. This optimization is strictly applied to single-renderstep shading draws, with explicit checks to prevent incorrect reordering of depth-only or multi-step draws. The `DrawListLayer` capability is also enabled in `src/gpu/graphite/Caps.cpp` to activate this feature, aiming to improve GPU utilization.

This commit addresses a **minor typo fix** within the **Graphite GPU backend's UniformManager**. Specifically, it corrects the `SkSLType` template parameter from `kUint` to `kUInt` when handling `uint32_t` uniforms in `src/gpu/graphite/UniformManager.h`. This **maintenance** change ensures the accurate representation of unsigned integer types within the shader language, preventing potential type-related inconsistencies or compilation issues. The scope of this fix is limited to the `write` operation for uniforms in Graphite.

This commit introduces a **new capability** to the **Graphite** rendering backend by enabling its `UniformManager` to handle `uint32_t` scalar values. An overload has been added to the `write` method within `src/gpu/graphite/UniformManager.h` specifically to support writing these unsigned 32-bit integer scalars. This enhancement expands the range of data types that can be efficiently managed and passed as uniforms to shaders within **Graphite**. Consequently, it improves the backend's flexibility and allows for more precise control over shader inputs where unsigned integer types are required.

This commit introduces the foundational infrastructure for **sparse strips** within the **Graphite** rendering engine, specifically focusing on **MSAA coverage Look-Up Tables (LUTs)**. It adds a new `MSAA_LUT` class and `GenerateMSAALUT` function, which is now used to **generate and store the MSAA coverage LUT directly on the `GlobalCache`**. This **new capability** makes the MSAA LUT globally accessible for sparse strips rendering, enabling the `kCPUSparseStripsMSAA8` path renderer strategy. The feature is controlled by the `skia_enable_sparse_strips` build argument and includes new build files, stub implementations for `StripGenerator`, and dedicated tests for the LUT accuracy.

This commit introduces a **new capability** in the **Graphite rendering backend** by adding sub-layer insertion tracking. It **refactors** the draw list management to use a new `Insertion` type, which tracks the specific binding list a draw inserts into, rather than just the layer. This change, affecting modules like `ClipStack`, `Device`, and `DrawListLayer`, allows draws to potentially insert into the layer of their parent draw, providing more granular control over draw ordering. Consequently, the testing for draw order now explicitly searches forwards or backwards to match the layer traversal direction, ensuring correct rendering behavior.

This commit **refactors** the **Graphite rendering backend** to unify the processing of depth-only draws with general draw operations. Previously handled by a separate code path and dedicated data structures, depth-only draw logic is now integrated into the general-purpose draw recording mechanisms, specifically affecting `DrawListLayer` and `DrawListTypes`. This **simplifies the rendering pipeline** by removing redundant code paths and data structures, such as `DepthDraw` and `DepthDrawList`. The change **improves maintainability** and reduces complexity in how draw commands are ordered and processed, ensuring correct partial ordering by inserting depth-only bindlists at the head of a layer's list.

This commit **refactors** the **Graphite GPU backend** to significantly alter the ordering of **stencil draws** within the `DrawListLayer`. It transitions from a chained `ABCABCABC` draw order to a transposed `AAABBBCCC` order, replacing previous chained draws with dedicated stencil draws to allow for varying child draws and **improve batching**. This **maintenance** work involves updating `DrawListLayer.h` and `DrawListTypes.h` with new data structures and modifying the core stencil recording and snapping logic in `DrawListLayer.cpp`, particularly in methods like `snapDrawPass`, to support this new, more efficient system. The change aims to enhance rendering performance by optimizing how stencil operations are grouped and executed.

This commit **enables** the experimental `DrawListLayer` feature for performance testing within the **Skia infrastructure**. Specifically, it modifies `infra/bots/gen_tasks_logic/nano_flags.go` to pass the `--useDrawListLayer` argument to `nanobench` commands when the `TestDrawListLayer` configuration is active. This **feature enablement** initiates performance data collection on the new layering-based draw ordering system, allowing for its evaluation and refinement.

This commit **removes an erroneously added build job** from the **Graphite project's CI/CD configuration**. Specifically, the **Ubuntu Metal build job**, which was accidentally introduced, is now being reverted. This **maintenance cleanup** ensures the build system operates efficiently by preventing the execution of unintended or incorrect build tasks.

This commit introduces **`DrawListLayer`**, an **experimental technique** for draw batching within the **Graphite** rendering engine. It redefines draw ordering by using bounded linear searches over lists of draws, guided by partial ordering requirements for various draw types (normal, stencil, depth-only, clipped). This involves significant **refactoring** of the **`ClipStack`**, **`Device`**, and **`DrawList`** interfaces to support the new layer-based approach, including immediate depth-only draws and updated clip state management. The new `DrawListLayer` aims to improve rendering efficiency by optimizing draw call submission. It is currently an **opt-in feature**, controlled by a new `useDrawListLayer` flag in `ContextOptionsPriv`, allowing for controlled testing and evaluation.

This commit performs a **refactoring** of the **Graphite testing and windowing infrastructure** by integrating a new `ContextOptionsPriv` member directly into the `skiatest::graphite::TestOptions` structure. This change centralizes the management of private context options, which were previously handled locally or through wrapper structs, across various Graphite backends like Dawn, Metal, and Vulkan. The `Viewer` and windowing contexts are updated to utilize this refactored `TestOptions`, streamlining context initialization and device creation. This is a **preparatory change** to enable setting these private context options directly from `CommonFlags`.

This commit introduces the **`kCPUSparseStripsMSAA8` path renderer strategy** into the **Graphite GPU backend**, laying the groundwork for a new rendering technique. It's a **new capability** that updates `src/gpu/graphite/RendererProvider.h` to define this strategy and modifies `src/gpu/graphite/Device.cpp` and `src/gpu/graphite/RendererProvider.cpp` to enable its recognition and selection during device creation. The **Skia Viewer tool** is also updated to integrate 'CPU Sparse Strips (8xMSAA)' as a selectable option, allowing developers to choose this strategy for testing and future implementation. This work establishes the necessary infrastructure for the `CPUSparseStripsMSAA8` renderer.

This commit introduces `DrawListBase`, a new **abstract base class** within the **Graphite** rendering backend, to centralize common draw list functionality. It **refactors** the existing `DrawList` to inherit from `DrawListBase`, moving shared logic, helper classes like `UniformTracker` and `TextureTracker`, and common members to the new base. Consequently, the `DrawContext` is updated to manage `DrawListBase` objects, promoting a more flexible and extensible design for **draw list management**. This **refactoring** lays the groundwork for future specialized draw list implementations by establishing a common interface.

This commit **fixes a critical bug** in **Graphite's SDF LCD text rendering** where the `sample_indexed_atlas_lcd` function in the fragment shader incorrectly sampled glyphs. Missing `break` statements in a switch block caused fall-through, leading to incorrect sampling of only the first atlas page instead of the intended one. This **bug fix** ensures **correct atlas indexing** for **SDF LCD text**, resolving rendering issues that occurred when many unique glyphs filled the atlas. A **new GM test case** (`crbug_478659067.cpp`) was added to reproduce and prevent regressions, alongside clarifying comments in `SkScalerContext.cpp`, `SubRunContainer.cpp`, and `SubRunControl.cpp` to improve understanding of SDF LCD text handling.

This commit **relands** a previous **refactoring** change for the **graphite** module's precompile tests. It **separates the input generation logic** from `tests/graphite/precompile/PaintParamsKeyTest.cpp` into new utility files, `tests/graphite/precompile/PaintParamsTestUtils.cpp` and `tests/graphite/precompile/PaintParamsTestUtils.h`. These new files now house comprehensive functions for generating random paint parameters, shaders, blenders, and filters, significantly **improving test code organization and maintainability**. This re-application indicates that the previous blocking issue that caused its revert has been resolved, allowing this beneficial test **refactoring** to proceed.

This commit **refactors** the **Graphite test suite** by relocating `PaintParamsTestUtils.cpp` and `PaintParamsTestUtils.h` into a new `precompile` subdirectory. This **organizational change** updates the include paths in `PaintParamsKeyTest.cpp` and modifies `gn/tests.gni` to reflect the new file locations for proper compilation. The move helps to better structure the test utilities specific to precompilation within the **Graphite module**, ensuring continued build integrity without altering test logic or functionality.

This commit performs a **refactoring** of the **Graphite testing infrastructure** by extracting input generation logic from the `PaintParamsKeyTest.cpp` file. It introduces new utility files, `PaintParamsTestUtils.cpp` and `PaintParamsTestUtils.h`, which now house a comprehensive set of helper functions for creating various `SkShader`, `SkBlender`, `SkColorFilter`, and `SkImageFilter` objects. This **maintenance** effort improves the **readability and reusability** of test code within **Graphite**, allowing other tests to leverage these standardized input generation routines. The `PaintParamsKeyTest` is updated to use these new utilities, streamlining its implementation.

This commit performs a significant **refactoring** within the **Graphite GPU backend**, specifically targeting its flushing mechanisms. It **removes complex recursive flushing logic** from the `Recorder`'s `flushTrackedDevices` method and eliminates a workaround for recursive calls within the `Device`'s `flushPendingWork`. This change simplifies the internal state management during GPU command buffer submission and device cleanup. Debug-only flags and assertions have been introduced to validate the flushing state, leading to a **cleaner and more robust internal flushing mechanism** for Graphite's GPU operations.

This commit **refactors** the **Graphite GPU backend's** `Device` component by **simplifying** the internal logic within the `drawGeometry` function. It cleans up how geometry is rendered with stroke and fill styles, reordering drawing operations to address awkward code leftover from an early extraction. This **cleanup** improves the maintainability and clarity of the **Graphite rendering pipeline** for geometry drawing.