Background Execution Implementation for iOS

lib/ui/dart_runtime_hooks.cc

@@ -48,23 +48,27 @@ namespace blink {
 #define BUILTIN_NATIVE_LIST(V) \
   V(Logger_PrintString, 1)     \
   V(SaveCompilationTrace, 0)   \
-  V(ScheduleMicrotask, 1)
+  V(ScheduleMicrotask, 1)      \
+  V(LookupClosure, 3)          \
+  V(GetFunctionClassName, 1)   \
+  V(GetFunctionLibraryUrl, 1)  \
+  V(GetFunctionName, 1)
 
 BUILTIN_NATIVE_LIST(DECLARE_FUNCTION);
 
 void DartRuntimeHooks::RegisterNatives(tonic::DartLibraryNatives* natives) {
   natives->Register({BUILTIN_NATIVE_LIST(REGISTER_FUNCTION)});
 }
 
-static Dart_Handle GetClosure(Dart_Handle builtin_library, const char* name) {
+static Dart_Handle GetFunction(Dart_Handle builtin_library, const char* name) {
   Dart_Handle getter_name = ToDart(name);
   Dart_Handle closure = Dart_Invoke(builtin_library, getter_name, 0, nullptr);
   DART_CHECK_VALID(closure);
   return closure;
 }
 
 static void InitDartInternal(Dart_Handle builtin_library, bool is_ui_isolate) {
-  Dart_Handle print = GetClosure(builtin_library, "_getPrintClosure");
+  Dart_Handle print = GetFunction(builtin_library, "_getPrintClosure");
 
   Dart_Handle internal_library = Dart_LookupLibrary(ToDart("dart:_internal"));
 
@@ -101,7 +105,7 @@ static void InitDartAsync(Dart_Handle builtin_library, bool is_ui_isolate) {
   Dart_Handle schedule_microtask;
   if (is_ui_isolate) {
     schedule_microtask =
-        GetClosure(builtin_library, "_getScheduleMicrotaskClosure");
+        GetFunction(builtin_library, "_getScheduleMicrotaskClosure");
   } else {
     Dart_Handle isolate_lib = Dart_LookupLibrary(ToDart("dart:isolate"));
     Dart_Handle method_name =
@@ -125,7 +129,8 @@ static void InitDartIO(Dart_Handle builtin_library,
     DART_CHECK_VALID(Dart_SetField(platform_type, ToDart("_nativeScript"),
                                    ToDart(script_uri)));
   }
-  Dart_Handle locale_closure = GetClosure(builtin_library, "_getLocaleClosure");
+  Dart_Handle locale_closure =
+      GetFunction(builtin_library, "_getLocaleClosure");
   DART_CHECK_VALID(
       Dart_SetField(platform_type, ToDart("_localeClosure"), locale_closure));
 }
@@ -223,4 +228,118 @@ void ScheduleMicrotask(Dart_NativeArguments args) {
   UIDartState::Current()->ScheduleMicrotask(closure);
 }
 
+void LookupClosure(Dart_NativeArguments args) {
+  Dart_Handle closure_name = Dart_GetNativeArgument(args, 0);
+  Dart_Handle library_name = Dart_GetNativeArgument(args, 1);
+  Dart_Handle class_name = Dart_GetNativeArgument(args, 2);
+  DART_CHECK_VALID(closure_name);
+  DART_CHECK_VALID(library_name);
+  DART_CHECK_VALID(class_name);
+
+  Dart_Handle library;
+  if (library_name == Dart_Null()) {
+    library = Dart_RootLibrary();
+  } else {
+    library = Dart_LookupLibrary(library_name);
+  }
+  DART_CHECK_VALID(library);
+
+  Dart_Handle closure;
+  if (Dart_IsNull(class_name)) {
+    closure = Dart_GetClosure(library, closure_name);
+  } else {
+    Dart_Handle cls = Dart_GetClass(library, class_name);
+    DART_CHECK_VALID(cls);
+    if (Dart_IsNull(cls)) {
+      closure = Dart_Null();
+    } else {
+      closure = Dart_GetStaticMethodClosure(library, cls, closure_name);
+    }
+  }
+  DART_CHECK_VALID(closure);
+
+  Dart_SetReturnValue(args, closure);
+}
+
+void GetFunctionLibraryUrl(Dart_NativeArguments args) {
+  Dart_Handle closure = Dart_GetNativeArgument(args, 0);
+  if (Dart_IsClosure(closure)) {
+    closure = Dart_ClosureFunction(closure);
+    DART_CHECK_VALID(closure);
+  }
+
+  if (!Dart_IsFunction(closure)) {
+    Dart_SetReturnValue(args, Dart_Null());
+    return;
+  }
+
+  Dart_Handle url = Dart_Null();
+  Dart_Handle owner = Dart_FunctionOwner(closure);
+  if (Dart_IsInstance(owner)) {
+    owner = Dart_ClassLibrary(owner);
+  }
+  if (Dart_IsLibrary(owner)) {
+    url = Dart_LibraryUrl(owner);
+    DART_CHECK_VALID(url);
+  }
+  Dart_SetReturnValue(args, url);
+}
+
+void GetFunctionClassName(Dart_NativeArguments args) {
+  Dart_Handle closure = Dart_GetNativeArgument(args, 0);
+  Dart_Handle result;
+
+  if (Dart_IsClosure(closure)) {
+    closure = Dart_ClosureFunction(closure);
+    DART_CHECK_VALID(closure);
+  }
+
+  if (!Dart_IsFunction(closure)) {
+    Dart_SetReturnValue(args, Dart_Null());
+    return;
+  }
+
+  bool is_static = false;
+  result = Dart_FunctionIsStatic(closure, &is_static);
+  DART_CHECK_VALID(result);
+  if (!is_static) {
+    Dart_SetReturnValue(args, Dart_Null());
+    return;
+  }
+
+  result = Dart_FunctionOwner(closure);
+  DART_CHECK_VALID(result);
+
+  if (Dart_IsLibrary(result) || !Dart_IsInstance(result)) {
+    Dart_SetReturnValue(args, Dart_Null());
+    return;
+  }
+
+  result = Dart_ClassName(result);
+  DART_CHECK_VALID(result);
+  Dart_SetReturnValue(args, result);
+}
+
+void GetFunctionName(Dart_NativeArguments args) {
+  Dart_Handle func = Dart_GetNativeArgument(args, 0);
+  DART_CHECK_VALID(func);
+
+  if (Dart_IsClosure(func)) {
+    func = Dart_ClosureFunction(func);
+    DART_CHECK_VALID(func);
+  }
+
+  if (!Dart_IsFunction(func)) {
+    Dart_SetReturnValue(args, Dart_Null());
+    return;
+  }
+
+  Dart_Handle result = Dart_FunctionName(func);
+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+    return;
+  }
+  Dart_SetReturnValue(args, result);
+}
+
 }  // namespace blink

lib/ui/dart_ui.gni

@@ -11,6 +11,7 @@ dart_ui_files = [
   "$flutter_root/lib/ui/lerp.dart",
   "$flutter_root/lib/ui/natives.dart",
   "$flutter_root/lib/ui/painting.dart",
+  "$flutter_root/lib/ui/plugins.dart",
   "$flutter_root/lib/ui/pointer.dart",
   "$flutter_root/lib/ui/semantics.dart",
   "$flutter_root/lib/ui/text.dart",

lib/ui/natives.dart

@@ -48,6 +48,11 @@ dynamic _saveCompilationTrace() native 'SaveCompilationTrace';
 
 void _scheduleMicrotask(void callback()) native 'ScheduleMicrotask';
 
+Function _lookupClosure(String name, String libraryPath, String className) native 'LookupClosure';
+String _getNameOfFunctionClass(Function closure) native 'GetFunctionClassName';
+String _getFunctionLibraryUrl(Function closure) native 'GetFunctionLibraryUrl';
+String _getFunctionName(Function func) native 'GetFunctionName';
+
 // Required for gen_snapshot to work correctly.
 int _isolateId;
 

lib/ui/plugins.dart

@@ -0,0 +1,74 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+part of dart.ui;
+
+/// Functionality for Flutter plugin authors.
+abstract class PluginUtilities {
+  /// Get a closure instance for a specific static or top-level function given
+  /// a name.
+  ///
+  /// **Warning:** if the function corresponding with `name` is not referenced
+  /// explicitly (e.g., invoked, passed as a closure, etc.) it may be optimized
+  /// out of the compiled application. To prevent this, avoid hard coding names
+  /// as [String]s and  prefer to use `PluginUtilities.getNameOfFunction` to
+  /// retrieve the function's name.
+  ///
+  /// `name` is the name of the function we want a closure for. This is a
+  /// required parameter.
+  ///
+  /// `libraryPath` is the path which points to the library which contains the
+  /// function of interest. This path can be retrieved using
+  /// [PluginUtilities.getPathForFunctionLibrary]. If not specified, the root
+  /// library will be used for the function lookup.
+  ///
+  /// `className` is the name of the class in which function `name` is defined.
+  /// This parameter is required for retrieving closures for static methods. If
+  /// not provided, `name` is assumed to be referring to a top-level function.
+  ///
+  /// Returns a closure for `name` as a [Function] if the lookup was successful.
+  /// Otherwise, `null` is returned on error.
+  static Function getClosureByName({String name, String libraryPath, String className}) {
+    if (name == null) {
+      throw new ArgumentError.notNull('name');
+    }
+    return _lookupClosure(name, libraryPath, className);
+  }
+
+  /// Get the path for the library which contains a given method.
+  ///
+  /// `closure` is the closure of the function that we want to find the library
+  /// path for.
+  ///
+  /// Returns a [String] representing the path to the library which contains
+  /// `closure`. Returns `null` if an error occurs or `closure` is not found
+  static String getPathForFunctionLibrary(Function closure) {
+    if (closure == null) {
+      throw new ArgumentError.notNull('closure');
+    }
+    return _getFunctionLibraryUrl(closure);
+  }
+
+  /// Get the name of a [Function] as a [String].
+  ///
+  /// Returns a [String] representing the name of the function if the function
+  /// exists, otherwise `null` is returned.
+  static String getNameOfFunction(Function closure) {
+    if (closure == null) {
+      throw new ArgumentError.notNull('closure');
+    }
+    return _getFunctionName(closure);
+  }
+
+  /// Get the name of a class containing [Function] as a [String].
+  ///
+  /// Returns a [String] representing the name of the function if the function
+  /// exists and is a member of a class, otherwise `null` is returned.
+  static String getNameOfFunctionClass(Function closure) {
+    if(closure == null) {
+      throw new ArgumentError.notNull('closure');
+    }
+    return _getNameOfFunctionClass(closure);
+  }
+}

lib/ui/ui.dart

@@ -30,6 +30,7 @@ part 'isolate_name_server.dart';
 part 'lerp.dart';
 part 'natives.dart';
 part 'painting.dart';
+part 'plugins.dart';
 part 'pointer.dart';
 part 'semantics.dart';
 part 'text.dart';

runtime/dart_isolate.cc

@@ -482,6 +482,48 @@ bool DartIsolate::Run(const std::string& entrypoint_name) {
   return true;
 }
 
+FXL_WARN_UNUSED_RESULT
+bool DartIsolate::RunFromLibrary(const std::string& library_name,
+                                 const std::string& entrypoint_name) {
+  TRACE_EVENT0("flutter", "DartIsolate::RunFromLibrary");
+  if (phase_ != Phase::Ready) {
+    return false;
+  }
+
+  tonic::DartState::Scope scope(this);
+
+  Dart_Handle library = Dart_LookupLibrary(tonic::ToDart(library_name.c_str()));
+  if (tonic::LogIfError(library)) {
+    return false;
+  }
+
+  Dart_Handle entrypoint =
+      Dart_GetClosure(library, tonic::ToDart(entrypoint_name.c_str()));
+  if (tonic::LogIfError(entrypoint)) {
+    return false;
+  }
+
+  Dart_Handle isolate_lib = Dart_LookupLibrary(tonic::ToDart("dart:isolate"));
+  if (tonic::LogIfError(isolate_lib)) {
+    return false;
+  }
+
+  Dart_Handle isolate_args[] = {
+      entrypoint,
+      Dart_Null(),
+  };
+
+  if (tonic::LogIfError(Dart_Invoke(
+          isolate_lib, tonic::ToDart("_startMainIsolate"),
+          sizeof(isolate_args) / sizeof(isolate_args[0]), isolate_args))) {
+    return false;
+  }
+
+  phase_ = Phase::Running;
+  FXL_DLOG(INFO) << "New isolate is in the running state.";
+  return true;
+}
+
 bool DartIsolate::Shutdown() {
   TRACE_EVENT0("flutter", "DartIsolate::Shutdown");
   // This call may be re-entrant since Dart_ShutdownIsolate can invoke the

runtime/dart_isolate.h

@@ -79,6 +79,10 @@ class DartIsolate : public UIDartState {
   FXL_WARN_UNUSED_RESULT
   bool Run(const std::string& entrypoint);
 
+  FXL_WARN_UNUSED_RESULT
+  bool RunFromLibrary(const std::string& library_name,
+                      const std::string& entrypoint);
+
   FXL_WARN_UNUSED_RESULT
   bool Shutdown();
 

shell/common/engine.cc

@@ -152,9 +152,17 @@ bool Engine::PrepareAndLaunchIsolate(RunConfiguration configuration) {
     return false;
   }
 
-  if (!isolate->Run(configuration.GetEntrypoint())) {
-    FXL_LOG(ERROR) << "Could not run the isolate.";
-    return false;
+  if (configuration.GetEntrypointLibrary().empty()) {
+    if (!isolate->Run(configuration.GetEntrypoint())) {
+      FXL_LOG(ERROR) << "Could not run the isolate.";
+      return false;
+    }
+  } else {
+    if (!isolate->RunFromLibrary(configuration.GetEntrypointLibrary(),
+                                 configuration.GetEntrypoint())) {
+      FXL_LOG(ERROR) << "Could not run the isolate.";
+      return false;
+    }
   }
 
   return true;

shell/common/run_configuration.cc

@@ -60,6 +60,12 @@ void RunConfiguration::SetEntrypoint(std::string entrypoint) {
   entrypoint_ = std::move(entrypoint);
 }
 
+void RunConfiguration::SetEntrypointAndLibrary(std::string entrypoint,
+                                               std::string library) {
+  SetEntrypoint(entrypoint);
+  entrypoint_library_ = std::move(library);
+}
+
 fml::RefPtr<blink::AssetManager> RunConfiguration::GetAssetManager() const {
   return asset_manager_;
 }
@@ -68,6 +74,10 @@ const std::string& RunConfiguration::GetEntrypoint() const {
   return entrypoint_;
 }
 
+const std::string& RunConfiguration::GetEntrypointLibrary() const {
+  return entrypoint_library_;
+}
+
 std::unique_ptr<IsolateConfiguration>
 RunConfiguration::TakeIsolateConfiguration() {
   return std::move(isolate_configuration_);

shell/common/run_configuration.h

@@ -37,16 +37,21 @@ class RunConfiguration {
 
   void SetEntrypoint(std::string entrypoint);
 
+  void SetEntrypointAndLibrary(std::string entrypoint, std::string library);
+
   fml::RefPtr<blink::AssetManager> GetAssetManager() const;
 
   const std::string& GetEntrypoint() const;
 
+  const std::string& GetEntrypointLibrary() const;
+
   std::unique_ptr<IsolateConfiguration> TakeIsolateConfiguration();
 
  private:
   std::unique_ptr<IsolateConfiguration> isolate_configuration_;
   fml::RefPtr<blink::AssetManager> asset_manager_;
   std::string entrypoint_ = "main";
+  std::string entrypoint_library_ = "";
 
   FXL_DISALLOW_COPY_AND_ASSIGN(RunConfiguration);
 };