Revert runtime changes:

Author: GaryQian

runtime/BUILD.gn

@@ -37,8 +37,6 @@ group("libdart") {
 
 source_set("runtime") {
   sources = [
-    "dart_deferred_load_handler.cc",
-    "dart_deferred_load_handler.h",
     "dart_isolate.cc",
     "dart_isolate.h",
     "dart_isolate_group_data.cc",

runtime/dart_deferred_load_handler.cc

@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "flutter/runtime/dart_isolate.h"
-#include "flutter/runtime/dart_deferred_load_handler.h"
 
 #include <cstdlib>
 #include <tuple>
@@ -87,7 +86,6 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
     std::string advisory_script_uri,
     std::string advisory_script_entrypoint,
     Flags isolate_flags,
-    Dart_DeferredLoadHandler& deferred_load_handler,
     const fml::closure& isolate_create_callback,
     const fml::closure& isolate_shutdown_callback,
     std::optional<std::string> dart_entrypoint,
@@ -118,7 +116,6 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
                                    advisory_script_uri,                //
                                    advisory_script_entrypoint,         //
                                    isolate_flags,                      //
-                                   deferred_load_handler,              //
                                    isolate_create_callback,            //
                                    isolate_shutdown_callback           //
                                    )
@@ -152,8 +149,8 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
   }
 
   if (settings.root_isolate_create_callback) {
-    // Isolate callbacks always occur in isolate scope and before user code
-    // has had a chance to run.
+    // Isolate callbacks always occur in isolate scope and before user code has
+    // had a chance to run.
     tonic::DartState::Scope scope(isolate.get());
     settings.root_isolate_create_callback(*isolate.get());
   }
@@ -189,7 +186,6 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
     std::string advisory_script_uri,
     std::string advisory_script_entrypoint,
     Flags flags,
-    Dart_DeferredLoadHandler& deferred_load_handler,
     const fml::closure& isolate_create_callback,
     const fml::closure& isolate_shutdown_callback) {
   TRACE_EVENT0("flutter", "DartIsolate::CreateRootIsolate");
@@ -226,7 +222,7 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
   auto isolate_flags = flags.Get();
   Dart_Isolate vm_isolate = CreateDartIsolateGroup(
       std::move(isolate_group_data), std::move(isolate_data), &isolate_flags,
-      deferred_load_handler, error.error());
+      error.error());
 
   if (error) {
     FML_LOG(ERROR) << "CreateDartIsolateGroup failed: " << error.str();
@@ -292,8 +288,7 @@ std::string DartIsolate::GetServiceId() {
   return service_id;
 }
 
-bool DartIsolate::Initialize(Dart_Isolate dart_isolate,
-                             Dart_DeferredLoadHandler& deferred_load_handler) {
+bool DartIsolate::Initialize(Dart_Isolate dart_isolate) {
   TRACE_EVENT0("flutter", "DartIsolate::Initialize");
   if (phase_ != Phase::Uninitialized) {
     return false;
@@ -325,9 +320,6 @@ bool DartIsolate::Initialize(Dart_Isolate dart_isolate,
     return false;
   }
 
-  // Dart_SetDeferredLoadHandler(&DartDeferredLoadHandler);
-  Dart_SetDeferredLoadHandler(deferred_load_handler);
-
   if (!UpdateThreadPoolNames()) {
     return false;
   }
@@ -340,33 +332,6 @@ fml::RefPtr<fml::TaskRunner> DartIsolate::GetMessageHandlingTaskRunner() const {
   return message_handling_task_runner_;
 }
 
-bool DartIsolate::LoadLoadingUnit(intptr_t loading_unit_id,
-                                  const uint8_t* snapshot_data,
-                                  const uint8_t* snapshot_instructions) {
-  tonic::DartState::Scope scope(this);
-  Dart_Handle result = Dart_DeferredLoadComplete(loading_unit_id, snapshot_data,
-                                                 snapshot_instructions);
-  if (Dart_IsApiError(result)) {
-    FML_LOG(ERROR) << "LOADING FAILED " << loading_unit_id;
-    result =
-        Dart_DeferredLoadCompleteError(loading_unit_id, Dart_GetError(result),
-                                       /*transient*/ true);
-    return false;
-  }
-  return true;
-}
-
-void DartIsolate::LoadLoadingUnitFailure(intptr_t loading_unit_id,
-                                         const std::string error_message,
-                                         bool transient) {
-  tonic::DartState::Scope scope(this);
-  Dart_Handle result = Dart_DeferredLoadCompleteError(
-      loading_unit_id, error_message.c_str(), transient);
-  if (Dart_IsApiError(result)) {
-    FML_LOG(ERROR) << "Dart error: " << Dart_GetError(result);
-  }
-}
-
 void DartIsolate::SetMessageHandlingTaskRunner(
     fml::RefPtr<fml::TaskRunner> runner) {
   if (!IsRootIsolate() || !runner) {
@@ -684,8 +649,8 @@ bool DartIsolate::RunFromLibrary(std::optional<std::string> library_name,
 bool DartIsolate::Shutdown() {
   TRACE_EVENT0("flutter", "DartIsolate::Shutdown");
   // This call may be re-entrant since Dart_ShutdownIsolate can invoke the
-  // cleanup callback which deletes the embedder side object of the dart
-  // isolate (a.k.a. this).
+  // cleanup callback which deletes the embedder side object of the dart isolate
+  // (a.k.a. this).
   if (phase_ == Phase::Shutdown) {
     return false;
   }
@@ -751,9 +716,8 @@ Dart_Isolate DartIsolate::DartCreateAndStartServiceIsolate(
           DART_VM_SERVICE_ISOLATE_NAME,   // script uri
           DART_VM_SERVICE_ISOLATE_NAME,   // script entrypoint
           DartIsolate::Flags{flags},      // flags
-          DartDeferredLoadHandler::empty_dart_deferred_load_handler,
-          nullptr,  // isolate create callback
-          nullptr   // isolate shutdown callback
+          nullptr,                        // isolate create callback
+          nullptr                         // isolate shutdown callback
       );
 
   std::shared_ptr<DartIsolate> service_isolate = weak_service_isolate.lock();
@@ -816,9 +780,8 @@ Dart_Isolate DartIsolate::DartIsolateGroupCreateCallback(
     // The VM attempts to start the VM service for us on |Dart_Initialize|. In
     // such a case, the callback data will be null and the script URI will be
     // DART_VM_SERVICE_ISOLATE_NAME. In such cases, we just create the service
-    // isolate like normal but dont hold a reference to it at all. We also
-    // start this isolate since we will never again reference it from the
-    // engine.
+    // isolate like normal but dont hold a reference to it at all. We also start
+    // this isolate since we will never again reference it from the engine.
     return DartCreateAndStartServiceIsolate(package_root,    //
                                             package_config,  //
                                             flags,           //
@@ -863,8 +826,7 @@ Dart_Isolate DartIsolate::DartIsolateGroupCreateCallback(
           false)));                              // is_root_isolate
 
   Dart_Isolate vm_isolate = CreateDartIsolateGroup(
-      std::move(isolate_group_data), std::move(isolate_data), flags,
-      DartDeferredLoadHandler::empty_dart_deferred_load_handler, error);
+      std::move(isolate_group_data), std::move(isolate_data), flags, error);
 
   if (*error) {
     FML_LOG(ERROR) << "CreateDartIsolateGroup failed: " << error;
@@ -909,9 +871,7 @@ bool DartIsolate::DartIsolateInitializeCallback(void** child_callback_data,
           false)));                             // is_root_isolate
 
   // root isolate should have been created via CreateRootIsolate
-  if (!InitializeIsolate(
-          *embedder_isolate, isolate,
-          DartDeferredLoadHandler::empty_dart_deferred_load_handler, error)) {
+  if (!InitializeIsolate(*embedder_isolate, isolate, error)) {
     return false;
   }
 
@@ -927,7 +887,6 @@ Dart_Isolate DartIsolate::CreateDartIsolateGroup(
     std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data,
     std::unique_ptr<std::shared_ptr<DartIsolate>> isolate_data,
     Dart_IsolateFlags* flags,
-    Dart_DeferredLoadHandler& deferred_load_handler,
     char** error) {
   TRACE_EVENT0("flutter", "DartIsolate::CreateDartIsolateGroup");
 
@@ -943,14 +902,12 @@ Dart_Isolate DartIsolate::CreateDartIsolateGroup(
     return nullptr;
   }
 
-  // Ownership of the isolate data objects has been transferred to the Dart
-  // VM.
+  // Ownership of the isolate data objects has been transferred to the Dart VM.
   std::shared_ptr<DartIsolate> embedder_isolate(*isolate_data);
   isolate_group_data.release();
   isolate_data.release();
 
-  if (!InitializeIsolate(std::move(embedder_isolate), isolate,
-                         deferred_load_handler, error)) {
+  if (!InitializeIsolate(std::move(embedder_isolate), isolate, error)) {
     return nullptr;
   }
 
@@ -960,10 +917,9 @@ Dart_Isolate DartIsolate::CreateDartIsolateGroup(
 bool DartIsolate::InitializeIsolate(
     std::shared_ptr<DartIsolate> embedder_isolate,
     Dart_Isolate isolate,
-    Dart_DeferredLoadHandler& deferred_load_handler,
     char** error) {
   TRACE_EVENT0("flutter", "DartIsolate::InitializeIsolate");
-  if (!embedder_isolate->Initialize(isolate, deferred_load_handler)) {
+  if (!embedder_isolate->Initialize(isolate)) {
     *error = fml::strdup("Embedder could not initialize the Dart isolate.");
     FML_DLOG(ERROR) << *error;
     return false;
@@ -976,9 +932,9 @@ bool DartIsolate::InitializeIsolate(
     return false;
   }
 
-  // Root isolates will be setup by the engine and the service isolate (which
-  // is also a root isolate) by the utility routines in the VM. However,
-  // secondary isolates will be run by the VM if they are marked as runnable.
+  // Root isolates will be setup by the engine and the service isolate (which is
+  // also a root isolate) by the utility routines in the VM. However, secondary
+  // isolates will be run by the VM if they are marked as runnable.
   if (!embedder_isolate->IsRootIsolate()) {
     auto child_isolate_preparer =
         embedder_isolate->GetIsolateGroupData().GetChildIsolatePreparer();

runtime/dart_deferred_load_handler.h

@@ -225,7 +225,6 @@ class DartIsolate : public UIDartState {
       std::string advisory_script_uri,
       std::string advisory_script_entrypoint,
       Flags flags,
-      Dart_DeferredLoadHandler& deferred_load_handler,
       const fml::closure& isolate_create_callback,
       const fml::closure& isolate_shutdown_callback,
       std::optional<std::string> dart_entrypoint,
@@ -385,14 +384,6 @@ class DartIsolate : public UIDartState {
   ///
   fml::RefPtr<fml::TaskRunner> GetMessageHandlingTaskRunner() const;
 
-  bool LoadLoadingUnit(intptr_t loading_unit_id,
-                       const uint8_t* snapshot_data,
-                       const uint8_t* snapshot_instructions);
-
-  void LoadLoadingUnitFailure(intptr_t loading_unit_id,
-                              const std::string error_message,
-                              bool transient);
-
  private:
   friend class IsolateConfiguration;
   class AutoFireClosure {
@@ -427,7 +418,6 @@ class DartIsolate : public UIDartState {
       std::string advisory_script_uri,
       std::string advisory_script_entrypoint,
       Flags flags,
-      Dart_DeferredLoadHandler& deferred_load_handler,
       const fml::closure& isolate_create_callback,
       const fml::closure& isolate_shutdown_callback);
 
@@ -442,9 +432,7 @@ class DartIsolate : public UIDartState {
               std::string advisory_script_entrypoint,
               bool is_root_isolate);
 
-  [[nodiscard]] bool Initialize(
-      Dart_Isolate isolate,
-      Dart_DeferredLoadHandler& deferred_load_handler);
+  [[nodiscard]] bool Initialize(Dart_Isolate isolate);
 
   void SetMessageHandlingTaskRunner(fml::RefPtr<fml::TaskRunner> runner);
 
@@ -484,12 +472,10 @@ class DartIsolate : public UIDartState {
       std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data,
       std::unique_ptr<std::shared_ptr<DartIsolate>> isolate_data,
       Dart_IsolateFlags* flags,
-      Dart_DeferredLoadHandler& deferred_load_handler,
       char** error);
 
   static bool InitializeIsolate(std::shared_ptr<DartIsolate> embedder_isolate,
                                 Dart_Isolate isolate,
-                                Dart_DeferredLoadHandler& deferred_load_handler,
                                 char** error);
 
   // |Dart_IsolateShutdownCallback|