Simplify runner app exit code. (#13074)

# Objective

Both the shedule and winit runners use/reimplement `app_exit_manual`
even tough they can use `app_exit`

## Solution

Nuke `app_exit_manual` from orbit.

crates/bevy_app/src/app.rs

@@ -867,17 +867,7 @@ impl App {
     pub fn should_exit(&self) -> Option<AppExit> {
         let mut reader = ManualEventReader::default();
 
-        self.should_exit_manual(&mut reader)
-    }
-
-    /// Several app runners in this crate keep their own [`ManualEventReader<AppExit>`].
-    /// This exists to accommodate them.
-    pub(crate) fn should_exit_manual(
-        &self,
-        reader: &mut ManualEventReader<AppExit>,
-    ) -> Option<AppExit> {
         let events = self.world().get_resource::<Events<AppExit>>()?;
-
         let mut events = reader.read(events);
 
         if events.len() != 0 {

crates/bevy_app/src/schedule_runner.rs

@@ -3,7 +3,6 @@ use crate::{
     plugin::Plugin,
     PluginsState,
 };
-use bevy_ecs::event::ManualEventReader;
 use bevy_utils::{Duration, Instant};
 
 #[cfg(target_arch = "wasm32")]
@@ -82,26 +81,25 @@ impl Plugin for ScheduleRunnerPlugin {
                 app.cleanup();
             }
 
-            let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
             match run_mode {
                 RunMode::Once => {
                     app.update();
 
-                    if let Some(exit) = app.should_exit_manual(&mut app_exit_event_reader) {
+                    if let Some(exit) = app.should_exit() {
                         return exit;
                     }
 
                     AppExit::Success
                 }
                 RunMode::Loop { wait } => {
-                    let mut tick = move |app: &mut App,
+                    let tick = move |app: &mut App,
                                      wait: Option<Duration>|
                           -> Result<Option<Duration>, AppExit> {
                         let start_time = Instant::now();
 
                         app.update();
 
-                        if let Some(exit) = app.should_exit_manual(&mut app_exit_event_reader) {
+                        if let Some(exit) = app.should_exit() {
                             return Err(exit);
                         };
 

crates/bevy_winit/src/lib.rs

@@ -286,7 +286,6 @@ pub fn winit_runner(mut app: App) -> AppExit {
     let handle_exit_status = exit_status.clone();
 
     // prepare structures to access data in the world
-    let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
     let mut redraw_event_reader = ManualEventReader::<RequestRedraw>::default();
 
     let mut focused_windows_state: SystemState<(Res<WinitSettings>, Query<&Window>)> =
@@ -308,7 +307,6 @@ pub fn winit_runner(mut app: App) -> AppExit {
 
         handle_winit_event(
             &mut app,
-            &mut app_exit_event_reader,
             &mut runner_state,
             &mut create_window,
             &mut event_writer_system_state,
@@ -337,7 +335,6 @@ pub fn winit_runner(mut app: App) -> AppExit {
 #[allow(clippy::too_many_arguments /* TODO: probs can reduce # of args */)]
 fn handle_winit_event(
     app: &mut App,
-    app_exit_event_reader: &mut ManualEventReader<AppExit>,
     runner_state: &mut WinitAppRunnerState,
     create_window: &mut SystemState<CreateWindowParams<Added<Window>>>,
     event_writer_system_state: &mut SystemState<(
@@ -366,19 +363,12 @@ fn handle_winit_event(
         }
         runner_state.redraw_requested = true;
 
-        // TODO: Replace with `App::should_exit()`
-        if let Some(app_exit_events) = app.world().get_resource::<Events<AppExit>>() {
-            let mut exit_events = app_exit_event_reader.read(app_exit_events);
-            if exit_events.len() != 0 {
-                *exit_status = exit_events
-                    .find(|exit| exit.is_error())
-                    .cloned()
-                    .unwrap_or(AppExit::Success);
+        if let Some(app_exit) = app.should_exit() {
+            *exit_status = app_exit;
             event_loop.exit();
             return;
         }
     }
-    }
 
     match event {
         Event::AboutToWait => {
@@ -430,7 +420,6 @@ fn handle_winit_event(
                         focused_windows_state,
                         event_loop,
                         create_window,
-                        app_exit_event_reader,
                         redraw_event_reader,
                         winit_events,
                         exit_status,
@@ -658,7 +647,6 @@ fn handle_winit_event(
                         focused_windows_state,
                         event_loop,
                         create_window,
-                        app_exit_event_reader,
                         redraw_event_reader,
                         winit_events,
                         exit_status,
@@ -759,7 +747,6 @@ fn run_app_update_if_should(
     focused_windows_state: &mut SystemState<(Res<WinitSettings>, Query<&Window>)>,
     event_loop: &EventLoopWindowTarget<UserEvent>,
     create_window: &mut SystemState<CreateWindowParams<Added<Window>>>,
-    app_exit_event_reader: &mut ManualEventReader<AppExit>,
     redraw_event_reader: &mut ManualEventReader<RequestRedraw>,
     winit_events: &mut Vec<WinitEvent>,
     exit_status: &mut AppExit,
@@ -822,19 +809,12 @@ fn run_app_update_if_should(
             }
         }
 
-        // TODO: Replace with `App::should_exit()`
-        if let Some(app_exit_events) = app.world().get_resource::<Events<AppExit>>() {
-            let mut exit_events = app_exit_event_reader.read(app_exit_events);
-            if exit_events.len() != 0 {
-                *exit_status = exit_events
-                    .find(|exit| exit.is_error())
-                    .cloned()
-                    .unwrap_or(AppExit::Success);
+        if let Some(app_exit) = app.should_exit() {
+            *exit_status = app_exit;
             event_loop.exit();
             return;
         }
     }
-    }
 
     // create any new windows
     // (even if app did not update, some may have been created by plugin setup)