Create root isolate asynchronously

Author: scutlight

runtime/runtime_controller.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#define FML_USED_ON_EMBEDDER
+
 #include "flutter/runtime/runtime_controller.h"
 
 #include "flutter/fml/message_loop.h"
@@ -44,47 +46,62 @@ RuntimeController::RuntimeController(
       window_data_(std::move(p_window_data)),
       isolate_create_callback_(p_isolate_create_callback),
       isolate_shutdown_callback_(p_isolate_shutdown_callback),
-      persistent_isolate_data_(std::move(p_persistent_isolate_data)) {
-  // Create the root isolate as soon as the runtime controller is initialized.
+      persistent_isolate_data_(std::move(p_persistent_isolate_data)),
+      weak_factory_(this) {
+  // Create the root isolate as soon as the runtime controller is initialized,
+  // but not using a synchronous way to avoid blocking the platform thread a
+  // long time as it is waiting while creating `Shell` on that platform thread.
   // It will be run at a later point when the engine provides a run
   // configuration and then runs the isolate.
-  auto strong_root_isolate =
-      DartIsolate::CreateRootIsolate(vm_->GetVMData()->GetSettings(),  //
-                                     isolate_snapshot_,                //
-                                     task_runners_,                    //
-                                     std::make_unique<Window>(this),   //
-                                     snapshot_delegate_,               //
-                                     io_manager_,                      //
-                                     unref_queue_,                     //
-                                     image_decoder_,                   //
-                                     p_advisory_script_uri,            //
-                                     p_advisory_script_entrypoint,     //
-                                     nullptr,                          //
-                                     isolate_create_callback_,         //
-                                     isolate_shutdown_callback_        //
-                                     )
-          .lock();
-
-  FML_CHECK(strong_root_isolate) << "Could not create root isolate.";
-
-  // The root isolate ivar is weak.
-  root_isolate_ = strong_root_isolate;
-
-  strong_root_isolate->SetReturnCodeCallback([this](uint32_t code) {
-    root_isolate_return_code_ = {true, code};
-  });
-
-  if (auto* window = GetWindowIfAvailable()) {
-    tonic::DartState::Scope scope(strong_root_isolate);
-    window->DidCreateIsolate();
-    if (!FlushRuntimeStateToIsolate()) {
-      FML_DLOG(ERROR) << "Could not setup initial isolate state.";
-    }
-  } else {
-    FML_DCHECK(false) << "RuntimeController created without window binding.";
-  }
-
-  FML_DCHECK(Dart_CurrentIsolate() == nullptr);
+  fml::MessageLoop::GetCurrent().GetTaskRunner()->PostTask(
+      [self = weak_factory_.GetWeakPtr()]() {
+        if (!self) {
+          return;
+        }
+
+        auto strong_root_isolate =
+            DartIsolate::CreateRootIsolate(
+                self->vm_->GetVMData()->GetSettings(),  //
+                self->isolate_snapshot_,                //
+                self->task_runners_,                    //
+                std::make_unique<Window>(self.get()),   //
+                self->snapshot_delegate_,               //
+                self->io_manager_,                      //
+                self->unref_queue_,                     //
+                self->image_decoder_,                   //
+                self->advisory_script_uri_,             //
+                self->advisory_script_entrypoint_,      //
+                nullptr,                                //
+                self->isolate_create_callback_,         //
+                self->isolate_shutdown_callback_        //
+                )
+                .lock();
+        FML_CHECK(strong_root_isolate) << "Could not create root isolate.";
+
+        // The root isolate ivar is weak.
+        self->root_isolate_ = strong_root_isolate;
+
+        strong_root_isolate->SetReturnCodeCallback([self](uint32_t code) {
+          if (!self) {
+            return;
+          }
+
+          self->root_isolate_return_code_ = {true, code};
+        });
+
+        if (auto* window = self->GetWindowIfAvailable()) {
+          tonic::DartState::Scope scope(strong_root_isolate);
+          window->DidCreateIsolate();
+          if (!self->FlushRuntimeStateToIsolate()) {
+            FML_DLOG(ERROR) << "Could not setup initial isolate state.";
+          }
+        } else {
+          FML_DCHECK(false)
+              << "RuntimeController created without window binding.";
+        }
+
+        FML_DCHECK(Dart_CurrentIsolate() == nullptr);
+      });
 }
 
 RuntimeController::~RuntimeController() {

runtime/runtime_controller.h

@@ -472,6 +472,7 @@ class RuntimeController final : public WindowClient {
   const fml::closure isolate_create_callback_;
   const fml::closure isolate_shutdown_callback_;
   std::shared_ptr<const fml::Mapping> persistent_isolate_data_;
+  fml::WeakPtrFactory<RuntimeController> weak_factory_;
 
   Window* GetWindowIfAvailable();