Allow embedders to specify arbitrary data to the isolate on launch. (flutter#13047)

Since this is currently only meant to be used by the embedding internally, the setter in Objective-C is only exposed via the FlutterDartProject private class extension. Unit tests have been added to the shell_unittests harness.

Fixes flutter#37641

Author: chinmaygarde

DEPS

@@ -145,7 +145,7 @@ deps = {
    # and not have to specific specific hashes.
 
   'src/third_party/tonic':
-   Var('fuchsia_git') + '/tonic' + '@' + 'bd27b4549199df72fcaeefd259ebc12a31c2e4ee',
+   Var('fuchsia_git') + '/tonic' + '@' + '1a8ed9be2e2b56b32e888266d6db465d36012df4',
 
   'src/third_party/benchmark':
    Var('fuchsia_git') + '/third_party/benchmark' + '@' + 'a779ffce872b4c811beef482e18bd0b63626aa42',

ci/licenses_golden/licenses_third_party

@@ -1,4 +1,4 @@
-Signature: 500cc19ee17ba4703537a9ae9ac78b8f
+Signature: a2d49b14022a4fb8fc74726a0861087f
 
 UNUSED LICENSES:
 

common/settings.h

@@ -183,6 +183,14 @@ struct Settings {
   // soon as a frame is rasterized.
   FrameRasterizedCallback frame_rasterized_callback;
 
+  // This data will be available to the isolate immediately on launch via the
+  // Window.getPersistentIsolateData callback. This is meant for information
+  // that the isolate cannot request asynchronously (platform messages can be
+  // used for that purpose). This data is held for the lifetime of the shell and
+  // is available on isolate restarts in the the shell instance. Due to this,
+  // the buffer must be as small as possible.
+  std::shared_ptr<const fml::Mapping> persistent_isolate_data;
+
   std::string ToString() const;
 };
 

fml/mapping.cc

@@ -4,6 +4,7 @@
 
 #include "flutter/fml/mapping.h"
 
+#include <algorithm>
 #include <sstream>
 
 namespace fml {
@@ -67,6 +68,9 @@ std::unique_ptr<FileMapping> FileMapping::CreateReadExecute(
 
 DataMapping::DataMapping(std::vector<uint8_t> data) : data_(std::move(data)) {}
 
+DataMapping::DataMapping(const std::string& string)
+    : data_(string.begin(), string.end()) {}
+
 DataMapping::~DataMapping() = default;
 
 size_t DataMapping::GetSize() const {

fml/mapping.h

@@ -86,6 +86,8 @@ class DataMapping final : public Mapping {
  public:
   DataMapping(std::vector<uint8_t> data);
 
+  DataMapping(const std::string& string);
+
   ~DataMapping() override;
 
   // |Mapping|

lib/ui/window.dart

@@ -1176,6 +1176,18 @@ class Window {
       registrationZone.runUnaryGuarded(callback, data);
     };
   }
+
+
+  /// The embedder can specify data that the isolate can request synchronously
+  /// on launch. This accessor fetches that data.
+  ///
+  /// This data is persistent for the duration of the Flutter application and is
+  /// available even after isolate restarts. Because of this lifecycle, the size
+  /// of this data must be kept to a minimum.
+  ///
+  /// For asynchronous communication between the embedder and isolate, a
+  /// platform channel may be used.
+  ByteData getPersistentIsolateData() native 'Window_getPersistentIsolateData';
 }
 
 /// Additional accessibility features that may be enabled by the platform.

lib/ui/window/window.cc

@@ -142,6 +142,20 @@ void _RespondToPlatformMessage(Dart_NativeArguments args) {
   tonic::DartCallStatic(&RespondToPlatformMessage, args);
 }
 
+void GetPersistentIsolateData(Dart_NativeArguments args) {
+  auto persistent_isolate_data =
+      UIDartState::Current()->window()->client()->GetPersistentIsolateData();
+
+  if (!persistent_isolate_data) {
+    Dart_SetReturnValue(args, Dart_Null());
+    return;
+  }
+
+  Dart_SetReturnValue(
+      args, tonic::DartByteData::Create(persistent_isolate_data->GetMapping(),
+                                        persistent_isolate_data->GetSize()));
+}
+
 }  // namespace
 
 Dart_Handle ToByteData(const std::vector<uint8_t>& buffer) {
@@ -398,6 +412,7 @@ void Window::RegisterNatives(tonic::DartLibraryNatives* natives) {
       {"Window_setIsolateDebugName", SetIsolateDebugName, 2, true},
       {"Window_reportUnhandledException", ReportUnhandledException, 2, true},
       {"Window_setNeedsReportTimings", SetNeedsReportTimings, 2, true},
+      {"Window_getPersistentIsolateData", GetPersistentIsolateData, 1, true},
   });
 }
 

lib/ui/window/window.h

@@ -57,6 +57,7 @@ class WindowClient {
   virtual void UpdateIsolateDescription(const std::string isolate_name,
                                         int64_t isolate_port) = 0;
   virtual void SetNeedsReportTimings(bool value) = 0;
+  virtual std::shared_ptr<const fml::Mapping> GetPersistentIsolateData() = 0;
 
  protected:
   virtual ~WindowClient();

lib/web_ui/lib/src/ui/window.dart

@@ -995,6 +995,8 @@ abstract class Window {
   String _initialLifecycleState;
 
   void setIsolateDebugName(String name) {}
+
+  ByteData getPersistentIsolateData() => null;
 }
 
 VoidCallback webOnlyScheduleFrameCallback;

runtime/runtime_controller.cc

@@ -26,7 +26,8 @@ RuntimeController::RuntimeController(
     std::string p_advisory_script_entrypoint,
     std::function<void(int64_t)> p_idle_notification_callback,
     fml::closure p_isolate_create_callback,
-    fml::closure p_isolate_shutdown_callback)
+    fml::closure p_isolate_shutdown_callback,
+    std::shared_ptr<const fml::Mapping> p_persistent_isolate_data)
     : RuntimeController(p_client,
                         p_vm,
                         std::move(p_isolate_snapshot),
@@ -39,7 +40,8 @@ RuntimeController::RuntimeController(
                         p_idle_notification_callback,
                         WindowData{/* default window data */},
                         p_isolate_create_callback,
-                        p_isolate_shutdown_callback) {}
+                        p_isolate_shutdown_callback,
+                        std::move(p_persistent_isolate_data)) {}
 
 RuntimeController::RuntimeController(
     RuntimeDelegate& p_client,
@@ -54,7 +56,8 @@ RuntimeController::RuntimeController(
     std::function<void(int64_t)> idle_notification_callback,
     WindowData p_window_data,
     fml::closure p_isolate_create_callback,
-    fml::closure p_isolate_shutdown_callback)
+    fml::closure p_isolate_shutdown_callback,
+    std::shared_ptr<const fml::Mapping> p_persistent_isolate_data)
     : client_(p_client),
       vm_(p_vm),
       isolate_snapshot_(std::move(p_isolate_snapshot)),
@@ -67,7 +70,8 @@ RuntimeController::RuntimeController(
       idle_notification_callback_(idle_notification_callback),
       window_data_(std::move(p_window_data)),
       isolate_create_callback_(p_isolate_create_callback),
-      isolate_shutdown_callback_(p_isolate_shutdown_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.
   // It will be run at a later point when the engine provides a run
   // configuration and then runs the isolate.
@@ -144,7 +148,8 @@ std::unique_ptr<RuntimeController> RuntimeController::Clone() const {
       idle_notification_callback_,  //
       window_data_,                 //
       isolate_create_callback_,     //
-      isolate_shutdown_callback_    //
+      isolate_shutdown_callback_,   //
+      persistent_isolate_data_      //
       ));
 }
 
@@ -296,42 +301,56 @@ Window* RuntimeController::GetWindowIfAvailable() {
   return root_isolate ? root_isolate->window() : nullptr;
 }
 
+// |WindowClient|
 std::string RuntimeController::DefaultRouteName() {
   return client_.DefaultRouteName();
 }
 
+// |WindowClient|
 void RuntimeController::ScheduleFrame() {
   client_.ScheduleFrame();
 }
 
+// |WindowClient|
 void RuntimeController::Render(Scene* scene) {
   client_.Render(scene->takeLayerTree());
 }
 
+// |WindowClient|
 void RuntimeController::UpdateSemantics(SemanticsUpdate* update) {
   if (window_data_.semantics_enabled) {
     client_.UpdateSemantics(update->takeNodes(), update->takeActions());
   }
 }
 
+// |WindowClient|
 void RuntimeController::HandlePlatformMessage(
     fml::RefPtr<PlatformMessage> message) {
   client_.HandlePlatformMessage(std::move(message));
 }
 
+// |WindowClient|
 FontCollection& RuntimeController::GetFontCollection() {
   return client_.GetFontCollection();
 }
 
+// |WindowClient|
 void RuntimeController::UpdateIsolateDescription(const std::string isolate_name,
                                                  int64_t isolate_port) {
   client_.UpdateIsolateDescription(isolate_name, isolate_port);
 }
 
+// |WindowClient|
 void RuntimeController::SetNeedsReportTimings(bool value) {
   client_.SetNeedsReportTimings(value);
 }
 
+// |WindowClient|
+std::shared_ptr<const fml::Mapping>
+RuntimeController::GetPersistentIsolateData() {
+  return persistent_isolate_data_;
+}
+
 Dart_Port RuntimeController::GetMainPort() {
   std::shared_ptr<DartIsolate> root_isolate = root_isolate_.lock();
   return root_isolate ? root_isolate->main_port() : ILLEGAL_PORT;