refactor: linearize platform-specific stop process flow

Author: zouyonghe

src-tauri/src/main.rs

@@ -2385,75 +2385,99 @@ fn wait_for_child_exit(child: &mut Child, timeout: Duration) -> bool {
     }
 }
 
+fn run_stop_command(pid: u32, label: &str, program: &str, args: &[&str]) -> io::Result<ExitStatus> {
+    let status = Command::new(program)
+        .args(args)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .stdin(Stdio::null())
+        .status();
+
+    match &status {
+        Ok(exit_status) if exit_status.success() => {}
+        Ok(exit_status) => append_desktop_log(&format!(
+            "{label} returned non-zero: pid={pid}, status={exit_status:?}"
+        )),
+        Err(error) => append_desktop_log(&format!(
+            "{label} failed to start: pid={pid}, error={error}"
+        )),
+    }
+
+    status
+}
+
+fn compute_followup_wait(timeout: Duration, max_extra_wait: Duration) -> Duration {
+    if timeout.is_zero() {
+        Duration::ZERO
+    } else {
+        (timeout / 4)
+            .max(Duration::from_millis(FORCE_STOP_WAIT_MIN_MS))
+            .min(max_extra_wait)
+    }
+}
+
 /// Attempt to stop a child process gracefully within `timeout`.
 ///
 /// On the force-kill path, a follow-up wait is derived from `timeout` (`timeout / 4`)
 /// and capped per-platform:
 /// - Windows: up to 2200ms.
 /// - Non-Windows: up to 1500ms.
+#[cfg(target_os = "windows")]
 fn stop_child_process_gracefully(child: &mut Child, timeout: Duration) -> bool {
     let pid = child.id();
     let pid_arg = pid.to_string();
 
-    let run_stop_command = |label: &str, program: &str, args: &[&str]| -> io::Result<ExitStatus> {
-        let status = Command::new(program)
-            .args(args)
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .stdin(Stdio::null())
-            .status();
-
-        match &status {
-            Ok(exit_status) if exit_status.success() => {}
-            Ok(exit_status) => append_desktop_log(&format!(
-                "{label} returned non-zero: pid={pid}, status={exit_status:?}"
-            )),
-            Err(error) => append_desktop_log(&format!(
-                "{label} failed to start: pid={pid}, error={error}"
-            )),
-        }
-
-        status
-    };
-
-    #[cfg(target_os = "windows")]
     let graceful_status = run_stop_command(
+        pid,
         "taskkill graceful stop",
         "taskkill",
         &["/pid", &pid_arg, "/t"],
     );
-    #[cfg(not(target_os = "windows"))]
-    let graceful_status = run_stop_command("kill -TERM", "kill", &["-TERM", &pid_arg]);
 
     if wait_for_child_exit(child, timeout) {
         return true;
     }
 
-    #[cfg(target_os = "windows")]
     let force_status = run_stop_command(
+        pid,
         "taskkill force stop",
         "taskkill",
         &["/pid", &pid_arg, "/t", "/f"],
     );
-    #[cfg(not(target_os = "windows"))]
-    let force_status = run_stop_command("kill -KILL", "kill", &["-KILL", &pid_arg]);
 
-    #[cfg(target_os = "windows")]
-    let max_extra_wait = Duration::from_millis(FORCE_STOP_WAIT_MAX_WINDOWS_MS);
-    #[cfg(not(target_os = "windows"))]
-    let max_extra_wait = Duration::from_millis(FORCE_STOP_WAIT_MAX_NON_WINDOWS_MS);
+    let followup_wait = compute_followup_wait(
+        timeout,
+        Duration::from_millis(FORCE_STOP_WAIT_MAX_WINDOWS_MS),
+    );
+    append_desktop_log(&format!(
+        "child graceful stop timed out, force-kill issued: pid={pid}, graceful={graceful_status:?}, force={force_status:?}, followup_wait_ms={}",
+        followup_wait.as_millis(),
+    ));
+    wait_for_child_exit(child, followup_wait)
+}
 
-    let followup_wait = if timeout.is_zero() {
-        Duration::ZERO
-    } else {
-        (timeout / 4)
-            .max(Duration::from_millis(FORCE_STOP_WAIT_MIN_MS))
-            .min(max_extra_wait)
-    };
+#[cfg(not(target_os = "windows"))]
+fn stop_child_process_gracefully(child: &mut Child, timeout: Duration) -> bool {
+    let pid = child.id();
+    let pid_arg = pid.to_string();
+
+    let graceful_status = run_stop_command(pid, "kill -TERM", "kill", &["-TERM", &pid_arg]);
+
+    if wait_for_child_exit(child, timeout) {
+        return true;
+    }
+
+    let force_status = run_stop_command(pid, "kill -KILL", "kill", &["-KILL", &pid_arg]);
+
+    let followup_wait = compute_followup_wait(
+        timeout,
+        Duration::from_millis(FORCE_STOP_WAIT_MAX_NON_WINDOWS_MS),
+    );
     append_desktop_log(&format!(
         "child graceful stop timed out, force-kill issued: pid={pid}, graceful={graceful_status:?}, force={force_status:?}, followup_wait_ms={}",
         followup_wait.as_millis(),
     ));
+
     wait_for_child_exit(child, followup_wait)
 }