Add canvas clear service boundary

tests/app_core/document_canvas_tests.cpp

@@ -2,9 +2,30 @@
 #include "test_harness.h"
 
 #include <limits>
+#include <string>
 
 namespace {
 
+class FakeDocumentCanvasClearServices final : public pp::app::DocumentCanvasClearServices {
+public:
+    void clear_current_canvas(float r, float g, float b, float a) override
+    {
+        clear_calls += 1;
+        last_r = r;
+        last_g = g;
+        last_b = b;
+        last_a = a;
+        call_order += "clear;";
+    }
+
+    int clear_calls = 0;
+    float last_r = 0.0F;
+    float last_g = 0.0F;
+    float last_b = 0.0F;
+    float last_a = 0.0F;
+    std::string call_order;
+};
+
 void clear_plan_records_legacy_canvas_effects(pp::tests::Harness& harness)
 {
     const auto plan = pp::app::plan_document_canvas_clear(true, 0.0F, 0.1F, 0.2F, 0.3F);
@@ -45,6 +66,54 @@ void clear_plan_rejects_bad_color_channels(pp::tests::Harness& harness)
         0.0F));
 }
 
+void clear_executor_dispatches_color_to_service(pp::tests::Harness& harness)
+{
+    FakeDocumentCanvasClearServices services;
+    const auto plan = pp::app::plan_document_canvas_clear(true, 0.25F, 0.5F, 0.75F, 1.0F);
+    PP_EXPECT(harness, plan);
+    if (plan) {
+        PP_EXPECT(harness, pp::app::execute_document_canvas_clear_plan(plan.value(), services).ok());
+    }
+
+    PP_EXPECT(harness, services.clear_calls == 1);
+    PP_EXPECT(harness, services.last_r == 0.25F);
+    PP_EXPECT(harness, services.last_g == 0.5F);
+    PP_EXPECT(harness, services.last_b == 0.75F);
+    PP_EXPECT(harness, services.last_a == 1.0F);
+    PP_EXPECT(harness, services.call_order == "clear;");
+}
+
+void clear_executor_preserves_noop_without_canvas(pp::tests::Harness& harness)
+{
+    FakeDocumentCanvasClearServices services;
+    const auto plan = pp::app::plan_document_canvas_clear(false);
+    PP_EXPECT(harness, plan);
+    if (plan) {
+        PP_EXPECT(harness, pp::app::execute_document_canvas_clear_plan(plan.value(), services).ok());
+    }
+
+    PP_EXPECT(harness, services.clear_calls == 0);
+}
+
+void clear_executor_rejects_invalid_color(pp::tests::Harness& harness)
+{
+    FakeDocumentCanvasClearServices services;
+    pp::app::DocumentCanvasClearPlan plan;
+    plan.clears_canvas = true;
+    plan.records_undo = true;
+    plan.marks_unsaved = true;
+    plan.no_op = false;
+    plan.r = 0.0F;
+    plan.g = 0.0F;
+    plan.b = 1.5F;
+    plan.a = 0.0F;
+
+    const auto status = pp::app::execute_document_canvas_clear_plan(plan, services);
+    PP_EXPECT(harness, !status.ok());
+    PP_EXPECT(harness, status.code == pp::foundation::StatusCode::out_of_range);
+    PP_EXPECT(harness, services.clear_calls == 0);
+}
+
 } // namespace
 
 int main()
@@ -53,5 +122,8 @@ int main()
     harness.run("clear plan records legacy canvas effects", clear_plan_records_legacy_canvas_effects);
     harness.run("clear plan noops without canvas", clear_plan_noops_without_canvas);
     harness.run("clear plan rejects bad color channels", clear_plan_rejects_bad_color_channels);
+    harness.run("clear executor dispatches color to service", clear_executor_dispatches_color_to_service);
+    harness.run("clear executor preserves noop without canvas", clear_executor_preserves_noop_without_canvas);
+    harness.run("clear executor rejects invalid color", clear_executor_rejects_invalid_color);
     return harness.finish();
 }

tests/app_core/main_toolbar_tests.cpp

@@ -10,7 +10,11 @@ public:
     void invoke_undo() override { undo_calls += 1; }
     void invoke_redo() override { redo_calls += 1; }
     void clear_history() override { clear_history_calls += 1; }
-    void clear_canvas() override { clear_canvas_calls += 1; }
+    void clear_canvas(const pp::app::DocumentCanvasClearPlan& plan) override
+    {
+        clear_canvas_calls += 1;
+        last_clear = plan;
+    }
     void show_message_box() override { message_boxes += 1; }
     void show_settings_dialog() override { settings_dialogs += 1; }
 
@@ -34,6 +38,7 @@ public:
     int clear_canvas_calls = 0;
     int message_boxes = 0;
     int settings_dialogs = 0;
+    pp::app::DocumentCanvasClearPlan last_clear;
 };
 
 void direct_dialog_commands_are_available(pp::tests::Harness& harness)
@@ -107,6 +112,9 @@ void canvas_clear_requires_live_canvas(pp::tests::Harness& harness)
         PP_EXPECT(harness, clear.value().requires_canvas);
         PP_EXPECT(harness, clear.value().records_undo);
         PP_EXPECT(harness, clear.value().marks_unsaved);
+        PP_EXPECT(harness, clear.value().canvas_clear.clears_canvas);
+        PP_EXPECT(harness, clear.value().canvas_clear.records_undo);
+        PP_EXPECT(harness, clear.value().canvas_clear.marks_unsaved);
         PP_EXPECT(harness, !clear.value().no_op);
     }
 
@@ -123,6 +131,7 @@ void canvas_clear_requires_live_canvas(pp::tests::Harness& harness)
         PP_EXPECT(harness, missing_canvas.value().requires_canvas);
         PP_EXPECT(harness, !missing_canvas.value().records_undo);
         PP_EXPECT(harness, !missing_canvas.value().marks_unsaved);
+        PP_EXPECT(harness, !missing_canvas.value().canvas_clear.clears_canvas);
         PP_EXPECT(harness, missing_canvas.value().no_op);
     }
 }
@@ -165,6 +174,9 @@ void executor_dispatches_to_service_boundary(pp::tests::Harness& harness)
         const auto status = pp::app::execute_main_toolbar_plan(clear_canvas.value(), services);
         PP_EXPECT(harness, status.ok());
         PP_EXPECT(harness, services.clear_canvas_calls == 1);
+        PP_EXPECT(harness, services.last_clear.clears_canvas);
+        PP_EXPECT(harness, services.last_clear.records_undo);
+        PP_EXPECT(harness, services.last_clear.marks_unsaved);
     }
 
     auto redo_empty = pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::redo);