Fix an issue with infinite spinner whem loading dependencies

Author: kean

WordPress/Classes/ViewRelated/NewGutenberg/NewGutenbergViewController.swift

@@ -10,46 +10,6 @@ import WebKit
 import CocoaLumberjackSwift
 
 class NewGutenbergViewController: UIViewController, PostEditor, PublishingEditor {
-
-    enum EditorLoadingState {
-        /// We haven't done anything with the editor yet
-        ///
-        /// Valid states to transition to:
-        /// - .loadingDependencies
-        case uninitialized
-
-        /// We're loading the editor's dependencies
-        ///
-        /// Valid states to transition to:
-        /// - .loadingCancelled
-        /// - .dependencyError
-        /// - .dependenciesReady
-        case loadingDependencies(_ task: Task<Void, Error>)
-
-        /// We cancelled loading the editor's dependencies
-        ///
-        /// Valid states to transition to:
-        /// - .loadingDependencies
-        case loadingCancelled
-
-        /// An error occured while fetching dependencies
-        ///
-        /// Valid states to transition to:
-        /// - .loadingDependencies
-        case dependencyError(Error)
-
-        /// All dependencies have been loaded, so we're ready to start the editor
-        ///
-        /// Valid states to transition to:
-        /// - .ready
-        case dependenciesReady(EditorDependencies)
-
-        /// The editor is fully loaded and we've passed all required configuration and data to it
-        ///
-        /// There are no valid transition states from `.started`
-        case started
-    }
-
     struct EditorDependencies {
         let settings: String?
         let didLoadCookies: Bool
@@ -125,9 +85,7 @@ class NewGutenbergViewController: UIViewController, PostEditor, PublishingEditor
     private var suggestionViewBottomConstraint: NSLayoutConstraint?
     private var currentSuggestionsController: GutenbergSuggestionsViewController?
 
-    private var editorState: EditorLoadingState = .uninitialized
-    private var dependencyLoadingError: Error?
-    private var editorLoadingTask: Task<Void, Error>?
+    private var editorLoadingTask: Task<Void, Never>?
 
     // TODO: remove (none of these APIs are needed for the new editor)
     func prepopulateMediaItems(_ media: [Media]) {}
@@ -212,8 +170,6 @@ class NewGutenbergViewController: UIViewController, PostEditor, PublishingEditor
         configureNavigationBar()
         refreshInterface()
 
-        startLoadingDependencies()
-
         SiteSuggestionService.shared.prefetchSuggestionsIfNeeded(for: post.blog) {
             // Do nothing
         }
@@ -225,55 +181,17 @@ class NewGutenbergViewController: UIViewController, PostEditor, PublishingEditor
 //            DDLogError("Error syncing JETPACK: \(String(describing: error))")
 //        })
 
-        onViewDidLoad()
-    }
-
-    override func viewWillAppear(_ animated: Bool) {
-        super.viewWillAppear(animated)
-
-        if case .loadingDependencies = self.editorState {
-            self.showActivityIndicator()
+        editorLoadingTask = Task { @MainActor in
+            await loadEditor()
         }
 
-        if case .loadingCancelled = self.editorState {
-            startLoadingDependencies()
-        }
-    }
-
-    override func viewDidAppear(_ animated: Bool) {
-        super.viewDidAppear(animated)
-
-        if case .loadingCancelled = self.editorState {
-            preconditionFailure("Dependency loading should not be cancelled")
-        }
-
-        self.editorLoadingTask = Task {
-            do {
-                while case .loadingDependencies = self.editorState {
-                    try await Task.sleep(nanoseconds: 1000)
-                }
-
-                switch self.editorState {
-                    case .uninitialized: preconditionFailure("Dependencies must be initialized")
-                    case .loadingDependencies: preconditionFailure("Dependencies should not still be loading")
-                    case .loadingCancelled: preconditionFailure("Dependency loading should not be cancelled")
-                    case .dependencyError(let error): self.showEditorError(error)
-                    case .dependenciesReady(let dependencies): try await self.startEditor(settings: dependencies.settings)
-                    case .started: preconditionFailure("The editor should not already be started")
-                }
-            } catch {
-                self.showEditorError(error)
-            }
-        }
+        onViewDidLoad()
     }
 
     override func viewWillDisappear(_ animated: Bool) {
         super.viewWillDisappear(animated)
 
         if isBeingDismissedDirectlyOrByAncestor() {
-            if case .loadingDependencies(let task) = editorState {
-                task.cancel()
-            }
             editorLoadingTask?.cancel()
         }
     }
@@ -359,49 +277,27 @@ class NewGutenbergViewController: UIViewController, PostEditor, PublishingEditor
         }
     }
 
-    func startLoadingDependencies() {
-        switch self.editorState {
-        case .uninitialized:
-            break // This is fine – we're loading for the first time
-        case .loadingDependencies:
-            preconditionFailure("`startLoadingDependencies` should not be called while in the `.loadingDependencies` state")
-        case .loadingCancelled:
-            break // This is fine – we're loading after quickly switching posts
-        case .dependencyError:
-            break // We're retrying after an error
-        case .dependenciesReady:
-            preconditionFailure("`startLoadingDependencies` should not be called while in the `.dependenciesReady` state")
-        case .started:
-            preconditionFailure("`startLoadingDependencies` should not be called while in the `.started` state")
-        }
-
-        self.editorState = .loadingDependencies(Task {
-            do {
-                let dependencies = try await fetchEditorDependencies()
-                self.editorState = .dependenciesReady(dependencies)
-            } catch {
-                self.editorState = .dependencyError(error)
-            }
-        })
-    }
-
     @MainActor
-    func startEditor(settings: String?) async throws {
-        guard case .dependenciesReady = self.editorState else {
-            preconditionFailure("`startEditor` should only be called when the editor is in the `.dependenciesReady` state.")
-        }
+    private func loadEditor() async {
+        showActivityIndicator()
 
-        let updatedConfiguration = self.editorViewController.configuration.toBuilder()
-            .apply(settings) { $0.setEditorSettings($1) }
-            .setTitle(post.postTitle ?? "")
-            .setContent(post.content ?? "")
-            .build()
+        do {
+            let dependencies = try await fetchEditorDependencies()
 
-        self.editorViewController.updateConfiguration(updatedConfiguration)
-        self.editorViewController.startEditorSetup()
+            let configuration = editorViewController.configuration.toBuilder()
+                .apply(dependencies.settings) { $0.setEditorSettings($1) }
+                .setTitle(post.postTitle ?? "")
+                .setContent(post.content ?? "")
+                .build()
 
-        // Handles refreshing controls with state context after options screen is dismissed
-        editorContentWasUpdated()
+            editorViewController.updateConfiguration(configuration)
+            editorViewController.startEditorSetup()
+
+            // Handles refreshing controls with state context after options screen is dismissed
+            editorContentWasUpdated()
+        } catch {
+            // TODO: handle errors
+        }
     }
 
     // MARK: - Keyboard Observers