Extract dual stroke face execution

tests/paint_renderer/stroke_execution_tests.cpp

@@ -1301,6 +1301,74 @@ void retained_stroke_live_pass_retains_previous_pass_dirty_union_without_overrid
     PP_EXPECT(h, pass_dirty_faces[1]);
 }
 
+void retained_stroke_dual_pass_frame_callbacks_preserve_order(pp::tests::Harness& h)
+{
+    StrokeFrame frame;
+    frame.id = 21;
+    frame.shapes[0] = {
+        vertex_t(glm::vec2(1.0F, 1.0F)),
+        vertex_t(glm::vec2(2.0F, 1.0F)),
+        vertex_t(glm::vec2(2.0F, 2.0F)),
+    };
+    frame.shapes[3] = {
+        vertex_t(glm::vec2(3.0F, 3.0F)),
+        vertex_t(glm::vec2(4.0F, 3.0F)),
+        vertex_t(glm::vec2(4.0F, 4.0F)),
+    };
+
+    std::array<StrokeFrame, 1> frames { frame };
+    std::array<glm::vec4, 6> accumulated_dirty_boxes;
+    std::array<glm::vec4, 6> pass_dirty_boxes;
+    accumulated_dirty_boxes.fill(glm::vec4(64.0F, 64.0F, 0.0F, 0.0F));
+    pass_dirty_boxes.fill(glm::vec4(64.0F, 64.0F, 0.0F, 0.0F));
+    std::array<bool, 6> include_in_committed_dirty_box { true, true, true, true, true, true };
+
+    std::vector<std::string> events;
+    std::array<DummyFramebuffer, 6> face_framebuffers {};
+    for (int face_index = 0; face_index < 6; ++face_index) {
+        face_framebuffers[face_index].events = &events;
+        face_framebuffers[face_index].face_index = face_index;
+    }
+
+    const auto executed_faces = pp::panopainter::execute_legacy_canvas_stroke_dual_pass_frame_callbacks(
+        frames,
+        pp::renderer::Extent2D { .width = 64, .height = 64 },
+        accumulated_dirty_boxes,
+        pass_dirty_boxes,
+        include_in_committed_dirty_box,
+        [&](StrokeFrame& current_frame) {
+            events.push_back("begin-frame:" + std::to_string(current_frame.id));
+        },
+        [&](StrokeFrame&, int face_index, std::span<const vertex_t> vertices) {
+            events.push_back(
+                "prepare:" + std::to_string(face_index) + ":" + std::to_string(vertices.size()));
+        },
+        [&](StrokeFrame&, int face_index, std::span<const vertex_t>) {
+            events.push_back("execute:" + std::to_string(face_index));
+            return glm::vec4(
+                static_cast<float>(face_index + 10),
+                static_cast<float>(face_index + 11),
+                static_cast<float>(face_index + 12),
+                static_cast<float>(face_index + 13));
+        },
+        face_framebuffers,
+        true);
+
+    const std::vector<std::string> expected_events {
+        "begin-frame:21",
+        "prepare:0:3",
+        "bind:0",
+        "execute:0",
+        "unbind:0",
+        "prepare:3:3",
+        "bind:3",
+        "execute:3",
+        "unbind:3",
+    };
+    PP_EXPECT(h, executed_faces == 2U);
+    PP_EXPECT(h, events == expected_events);
+}
+
 void retained_stroke_pad_executor_copies_destination_for_dirty_faces_only(pp::tests::Harness& h)
 {
     const std::array<bool, 3> dirty_faces { true, false, true };
@@ -1573,6 +1641,9 @@ int main()
     harness.run(
         "retained_stroke_live_pass_face_framebuffers_helper_preserves_callback_order",
         retained_stroke_live_pass_face_framebuffers_helper_preserves_callback_order);
+    harness.run(
+        "retained_stroke_dual_pass_frame_callbacks_preserve_order",
+        retained_stroke_dual_pass_frame_callbacks_preserve_order);
     harness.run(
         "retained_stroke_live_pass_sampler_dispatch_helper_builds_expected_callback_wiring",
         retained_stroke_live_pass_sampler_dispatch_helper_builds_expected_callback_wiring);