Background Execution Implementation for iOS

lib/ui/plugins.dart

@@ -4,28 +4,61 @@
 
 part of dart.ui;
 
+/// Functionality for Flutter plugin authors.
 abstract class PluginUtilities {
-  static Function getClosureByName({String name, Uri libraryUri, String className}) {
+  /// Get a closure instance for a specific static or top-level function given
+  /// a name.
+  ///
+  /// `name` is the name of the function we want a closure for. This is a
+  /// required parameter.
+  ///
+  /// `libraryPat h` 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, libraryUri?.toString(), className);
+    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');

testing/dart/plugin_utilities_test.dart

@@ -0,0 +1,90 @@
+// 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.
+
+import 'dart:io';
+import 'dart:ui';
+
+import 'package:test/test.dart';
+
+String top() => "top";
+
+class Foo {
+  const Foo();
+  static int getInt() => 1;
+  double getDouble() => 1.0;
+}
+
+const Foo foo = const Foo();
+
+void main() {
+  test('PluginUtilities.getNameOf*', () {
+    expect(PluginUtilities.getNameOfFunction(top), "top");
+    expect(PluginUtilities.getNameOfFunction(Foo.getInt), "getInt");
+    expect(PluginUtilities.getNameOfFunction(foo.getDouble), 'getDouble');
+    expect(() => PluginUtilities.getNameOfFunction(null),
+        throwsA(const isInstanceOf<ArgumentError>()));
+
+    expect(PluginUtilities.getNameOfFunctionClass(top), null);
+    expect(PluginUtilities.getNameOfFunctionClass(Foo.getInt), 'Foo');
+    expect(() => PluginUtilities.getNameOfFunctionClass(null),
+        throwsA(const isInstanceOf<ArgumentError>()));
+
+    // Can't lookup class name for instance functions.
+    expect(PluginUtilities.getNameOfFunctionClass(foo.getDouble), isNull);
+  });
+
+  test('PluginUtilities.getPathForFunctionLibrary', () {
+    const String file = 'plugin_utilities_test.dart';
+    expect(
+        PluginUtilities.getPathForFunctionLibrary(top).endsWith(file), isTrue);
+    expect(PluginUtilities.getPathForFunctionLibrary(Foo.getInt).endsWith(file),
+        isTrue);
+    expect(
+        PluginUtilities.getPathForFunctionLibrary(foo.getDouble).endsWith(file),
+        isTrue);
+
+    expect(() => PluginUtilities.getPathForFunctionLibrary(null),
+        throwsA(const isInstanceOf<ArgumentError>()));
+  });
+
+  test('PluginUtilities.getClosureByName', () {
+    final String getIntName = PluginUtilities.getNameOfFunction(Foo.getInt);
+    final String getDoubleName =
+        PluginUtilities.getNameOfFunction(foo.getDouble);
+    final String topName = PluginUtilities.getNameOfFunction(top);
+    final String fooName = PluginUtilities.getNameOfFunctionClass(Foo.getInt);
+    final String libName = PluginUtilities.getPathForFunctionLibrary(top);
+
+    // We should successfully get a closure for top level and static methods.
+    expect(
+        PluginUtilities.getClosureByName(
+            name: getIntName, libraryPath: libName, className: fooName)(),
+        1);
+    expect(
+        PluginUtilities.getClosureByName(name: topName, libraryPath: libName)(),
+        'top');
+
+    // We don't support getting closures for instance methods.
+    expect(
+        PluginUtilities.getClosureByName(
+            name: getDoubleName, libraryPath: libName, className: fooName),
+        null);
+
+    // Try an invalid function name.
+    expect(PluginUtilities.getClosureByName(name: 'baz'), null);
+    expect(() => PluginUtilities.getClosureByName(),
+        throwsA(const isInstanceOf<ArgumentError>()));
+
+    // Lookup from root library.
+    expect(
+        PluginUtilities.getClosureByName(
+            name: getIntName, className: fooName)(),
+        1);
+    expect(PluginUtilities.getClosureByName(name: topName)(), 'top');
+    expect(
+        PluginUtilities.getClosureByName(
+            name: getDoubleName, className: fooName),
+        null);
+  });
+}