Remove dead sync_process_findings / determine_process_method / process_results scaffolding (#14351)

These three methods were introduced to support the ASYNC_FINDING_IMPORT feature
(async dispatch of findings processing to Celery). That feature has since been
removed, leaving a three-layer indirection:

  process_scan -> determine_process_method -> sync_process_findings -> process_findings
                                                                 -> process_results

None of this routing logic has any effect anymore:
- sync_process_findings just delegates to process_findings
- determine_process_method just delegates to sync_process_findings
- process_results just returns self.new_items / self.reactivated_items / etc.

Collapse the call chain so process_scan calls process_findings directly and
process_findings returns the finding lists directly. This also fixes the
indirection that was the root cause of #14309's performance test failures.

Author: valentijnscholten

dojo/importers/base_importer.py

@@ -284,27 +284,6 @@ def parse_findings(
         logger.info(f"Parsing findings took {elapsed_time:.2f} seconds ({len(parsed_findings) if parsed_findings else 0} findings parsed)")
         return parsed_findings
 
-    def sync_process_findings(
-        self,
-        parsed_findings: list[Finding],
-        **kwargs: dict,
-    ) -> tuple[list[Finding], list[Finding], list[Finding], list[Finding]]:
-        """
-        Processes findings in a synchronous manner such that all findings
-        will be processed in a worker/process/thread
-        """
-        return self.process_findings(parsed_findings, **kwargs)
-
-    def determine_process_method(
-        self,
-        parsed_findings: list[Finding],
-        **kwargs: dict,
-    ) -> list[Finding]:
-        return self.sync_process_findings(
-            parsed_findings,
-            **kwargs,
-        )
-
     def determine_deduplication_algorithm(self) -> str:
         """
         Determines what dedupe algorithm to use for the Test being processed.

dojo/importers/default_importer.py

@@ -110,8 +110,7 @@ def process_scan(
         # Get the findings from the parser based on what methods the parser supplies
         # This could either mean traditional file parsing, or API pull parsing
         parsed_findings = self.parse_findings(scan, parser) or []
-        # process the findings in the foreground or background
-        new_findings = self.determine_process_method(parsed_findings, **kwargs)
+        new_findings = self.process_findings(parsed_findings, **kwargs)
         # Close any old findings in the processed list if the the user specified for that
         # to occur in the form that is then passed to the kwargs
         closed_findings = self.close_old_findings(self.test.finding_set.all(), **kwargs)

dojo/importers/default_reimporter.py

@@ -102,13 +102,12 @@ def process_scan(
         # Get the findings from the parser based on what methods the parser supplies
         # This could either mean traditional file parsing, or API pull parsing
         parsed_findings = self.parse_findings(scan, parser) or []
-        # process the findings in the foreground or background
         (
             new_findings,
             reactivated_findings,
             findings_to_mitigate,
             untouched_findings,
-        ) = self.determine_process_method(parsed_findings, **kwargs)
+        ) = self.process_findings(parsed_findings, **kwargs)
         # Close any old findings in the processed list if the the user specified for that
         # to occur in the form that is then passed to the kwargs
         closed_findings = self.close_old_findings(findings_to_mitigate, **kwargs)
@@ -462,8 +461,7 @@ def process_findings(
         # Synchronous tasks were already executed during processing, just calculate grade
         perform_product_grading(self.test.engagement.product)
 
-        # Process the results and return them back
-        return self.process_results(**kwargs)
+        return self.new_items, self.reactivated_items, self.to_mitigate, self.untouched
 
     def close_old_findings(
         self,
@@ -1008,13 +1006,6 @@ def process_groups_for_all_findings(
                 if self.push_to_jira or is_keep_in_sync_with_jira(finding_group, prefetched_jira_instance=self.jira_instance):
                     jira_helper.push_to_jira(finding_group)
 
-    def process_results(
-        self,
-        **kwargs: dict,
-    ) -> tuple[list[Finding], list[Finding], list[Finding], list[Finding]]:
-        """Return the finding lists collected during process_findings."""
-        return self.new_items, self.reactivated_items, self.to_mitigate, self.untouched
-
     def calculate_unsaved_finding_hash_code(
         self,
         unsaved_finding: Finding,