Limit heap growth on Android

shell/common/switches.cc

@@ -401,6 +401,12 @@ Settings SettingsFromCommandLine(const fml::CommandLine& command_line) {
   settings.purge_persistent_cache =
       command_line.HasOption(FlagForSwitch(Switch::PurgePersistentCache));
 
+  if (command_line.HasOption(FlagForSwitch(Switch::OldGenHeapSize))) {
+    std::string old_gen_heap_size;
+    command_line.GetOptionValue(FlagForSwitch(Switch::OldGenHeapSize),
+                                &old_gen_heap_size);
+    settings.old_gen_heap_size = std::stoi(old_gen_heap_size);
+  }
   return settings;
 }
 

shell/common/switches.h

@@ -196,6 +196,9 @@ DEF_SWITCH(
     "Uses separate threads for the platform, UI, GPU and IO task runners. "
     "By default, a single thread is used for all task runners. Only available "
     "in the flutter_tester.")
+DEF_SWITCH(OldGenHeapSize,
+           "old-gen-heap-size",
+           "The size limit in megabytes for the Dart VM old gen heap space.")
 
 DEF_SWITCHES_END
 

shell/platform/android/io/flutter/FlutterInjector.java

@@ -62,23 +62,12 @@ public static void reset() {
     instance = null;
   }
 
-  private FlutterInjector(boolean shouldLoadNative, @NonNull FlutterLoader flutterLoader) {
-    this.shouldLoadNative = shouldLoadNative;
+  private FlutterInjector(@NonNull FlutterLoader flutterLoader) {
     this.flutterLoader = flutterLoader;
   }
 
-  private boolean shouldLoadNative;
   private FlutterLoader flutterLoader;
 
-  /**
-   * Returns whether the Flutter Android engine embedding should load the native C++ engine.
-   *
-   * <p>Useful for testing since JVM tests via Robolectric can't load native libraries.
-   */
-  public boolean shouldLoadNative() {
-    return shouldLoadNative;
-  }
-
   /** Returns the {@link FlutterLoader} instance to use for the Flutter Android engine embedding. */
   @NonNull
   public FlutterLoader flutterLoader() {
@@ -92,20 +81,6 @@ public FlutterLoader flutterLoader() {
    * <p>Non-overriden values have reasonable defaults.
    */
   public static final class Builder {
-
-    private boolean shouldLoadNative = true;
-    /**
-     * Sets whether the Flutter Android engine embedding should load the native C++ engine.
-     *
-     * <p>Useful for testing since JVM tests via Robolectric can't load native libraries.
-     *
-     * <p>Defaults to true.
-     */
-    public Builder setShouldLoadNative(boolean shouldLoadNative) {
-      this.shouldLoadNative = shouldLoadNative;
-      return this;
-    }
-
     private FlutterLoader flutterLoader;
     /**
      * Sets a {@link FlutterLoader} override.
@@ -130,8 +105,7 @@ private void fillDefaults() {
     public FlutterInjector build() {
       fillDefaults();
 
-      System.out.println("should load native is " + shouldLoadNative);
-      return new FlutterInjector(shouldLoadNative, flutterLoader);
+      return new FlutterInjector(flutterLoader);
     }
   }
 }

shell/platform/android/io/flutter/embedding/engine/FlutterJNI.java

@@ -94,6 +94,50 @@
  */
 @Keep
 public class FlutterJNI {
+  public static class FlutterJNILoader {
+    /**
+     * Loads the libflutter.so library.
+     *
+     * <p>This must be called before any other native methods, and can be overridden by tests to
+     * avoid loading native libraries.
+     */
+    public void loadLibrary() {
+      System.loadLibrary("flutter");
+    }
+
+    /**
+     * Prefetch the default font manager provided by SkFontMgr::RefDefault() which is a process-wide
+     * singleton owned by Skia. Note that, the first call to SkFontMgr::RefDefault() will take
+     * noticeable time, but later calls will return a reference to the preexisting font manager.
+     */
+    public void prefetchDefaultFontManager() {
+      FlutterJNI.nativePrefetchDefaultFontManager();
+    }
+
+    /**
+     * Perform one time initialization of the Dart VM and Flutter engine.
+     *
+     * <p>This method must be called only once.
+     *
+     * @param context The application context.
+     * @param args Arguments to the Dart VM/Flutter engine.
+     * @param bundlePath For JIT runtimes, the path to the Dart kernel file for the application.
+     * @param appStoragePath The path to the application data directory.
+     * @param engineCachesPath The path to the application cache directory.
+     * @param initTimeMillis The time, in milliseconds, taken for initialization.
+     */
+    public void nativeInit(
+        @NonNull Context context,
+        @NonNull String[] args,
+        @Nullable String bundlePath,
+        @NonNull String appStoragePath,
+        @NonNull String engineCachesPath,
+        long initTimeMillis) {
+      FlutterJNI.nativeInit(
+          context, args, bundlePath, appStoragePath, engineCachesPath, initTimeMillis);
+    }
+  }
+
   private static final String TAG = "FlutterJNI";
 
   @Nullable private static AsyncWaitForVsyncDelegate asyncWaitForVsyncDelegate;
@@ -104,21 +148,15 @@ public class FlutterJNI {
   // This is set from native code via JNI.
   @Nullable private static String observatoryUri;
 
-  // TODO(mattcarroll): add javadocs
-  public static native void nativeInit(
+  private static native void nativeInit(
       @NonNull Context context,
       @NonNull String[] args,
       @Nullable String bundlePath,
       @NonNull String appStoragePath,
       @NonNull String engineCachesPath,
       long initTimeMillis);
 
-  /**
-   * Prefetch the default font manager provided by SkFontMgr::RefDefault() which is a process-wide
-   * singleton owned by Skia. Note that, the first call to SkFontMgr::RefDefault() will take
-   * noticeable time, but later calls will return a reference to the preexisting font manager.
-   */
-  public static native void nativePrefetchDefaultFontManager();
+  private static native void nativePrefetchDefaultFontManager();
 
   private native boolean nativeGetIsSoftwareRenderingEnabled();
 

shell/platform/android/io/flutter/embedding/engine/loader/FlutterLoader.java

@@ -4,6 +4,7 @@
 
 package io.flutter.embedding.engine.loader;
 
+import android.app.ActivityManager;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.res.AssetManager;
@@ -15,7 +16,6 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import io.flutter.BuildConfig;
-import io.flutter.FlutterInjector;
 import io.flutter.embedding.engine.FlutterJNI;
 import io.flutter.util.PathUtils;
 import io.flutter.view.VsyncWaiter;
@@ -60,10 +60,22 @@ public static FlutterLoader getInstance() {
     return instance;
   }
 
+  public FlutterLoader() {
+    this(null);
+  }
+
+  public FlutterLoader(@Nullable FlutterJNI.FlutterJNILoader flutterJNILoader) {
+    if (flutterJNILoader == null) {
+      flutterJNILoader = new FlutterJNI.FlutterJNILoader();
+    }
+    this.flutterJNILoader = flutterJNILoader;
+  }
+
   private boolean initialized = false;
   @Nullable private Settings settings;
   private long initStartTimestampMillis;
   private FlutterApplicationInfo flutterApplicationInfo;
+  private FlutterJNI.FlutterJNILoader flutterJNILoader;
 
   private static class InitResult {
     final String appStoragePath;
@@ -125,9 +137,7 @@ public void startInitialization(@NonNull Context applicationContext, @NonNull Se
           public InitResult call() {
             ResourceExtractor resourceExtractor = initResources(appContext);
 
-            if (FlutterInjector.instance().shouldLoadNative()) {
-              System.loadLibrary("flutter");
-            }
+            flutterJNILoader.loadLibrary();
 
             // Prefetch the default font manager as soon as possible on a background thread.
             // It helps to reduce time cost of engine setup that blocks the platform thread.
@@ -136,7 +146,7 @@ public InitResult call() {
                     new Runnable() {
                       @Override
                       public void run() {
-                        FlutterJNI.nativePrefetchDefaultFontManager();
+                        flutterJNILoader.prefetchDefaultFontManager();
                       }
                     });
 
@@ -225,17 +235,20 @@ public void ensureInitializationComplete(
         shellArgs.add("--log-tag=" + settings.getLogTag());
       }
 
+      ActivityManager activityManager =
+          (ActivityManager) applicationContext.getSystemService(Context.ACTIVITY_SERVICE);
+      int oldGenHeapSizeMegaBytes = activityManager.getLargeMemoryClass();
+      shellArgs.add("--old-gen-heap-size=" + oldGenHeapSizeMegaBytes);
+
       long initTimeMillis = SystemClock.uptimeMillis() - initStartTimestampMillis;
 
-      if (FlutterInjector.instance().shouldLoadNative()) {
-        FlutterJNI.nativeInit(
-            applicationContext,
-            shellArgs.toArray(new String[0]),
-            kernelPath,
-            result.appStoragePath,
-            result.engineCachesPath,
-            initTimeMillis);
-      }
+      flutterJNILoader.nativeInit(
+          applicationContext,
+          shellArgs.toArray(new String[0]),
+          kernelPath,
+          result.appStoragePath,
+          result.engineCachesPath,
+          initTimeMillis);
 
       initialized = true;
     } catch (Exception e) {

shell/platform/android/test/io/flutter/FlutterInjectorTest.java

@@ -7,7 +7,6 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
 
 import io.flutter.embedding.engine.loader.FlutterLoader;
 import org.junit.Before;
@@ -35,7 +34,6 @@ public void itHasSomeReasonableDefaults() {
     // Implicitly builds when first accessed.
     FlutterInjector injector = FlutterInjector.instance();
     assertNotNull(injector.flutterLoader());
-    assertTrue(injector.shouldLoadNative());
   }
 
   @Test
@@ -44,7 +42,6 @@ public void canPartiallyOverride() {
         new FlutterInjector.Builder().setFlutterLoader(mockFlutterLoader).build());
     FlutterInjector injector = FlutterInjector.instance();
     assertEquals(injector.flutterLoader(), mockFlutterLoader);
-    assertTrue(injector.shouldLoadNative());
   }
 
   @Test()

shell/platform/android/test/io/flutter/embedding/engine/PluginComponentTest.java

@@ -32,11 +32,15 @@ public void setUp() {
   @Test
   public void pluginsCanAccessFlutterAssetPaths() {
     // Setup test.
-    FlutterInjector.setInstance(new FlutterInjector.Builder().setShouldLoadNative(false).build());
+    FlutterJNI.FlutterJNILoader mockFlutterJNILoader = mock(FlutterJNI.FlutterJNILoader.class);
+    FlutterInjector.setInstance(
+        new FlutterInjector.Builder()
+            .setFlutterLoader(new FlutterLoader(mockFlutterJNILoader))
+            .build());
     FlutterJNI flutterJNI = mock(FlutterJNI.class);
     when(flutterJNI.isAttached()).thenReturn(true);
 
-    FlutterLoader flutterLoader = new FlutterLoader();
+    FlutterLoader flutterLoader = new FlutterLoader(mockFlutterJNILoader);
 
     // Execute behavior under test.
     FlutterEngine flutterEngine =

shell/platform/android/test/io/flutter/embedding/engine/loader/FlutterLoaderTest.java

@@ -4,24 +4,31 @@
 
 package io.flutter.embedding.engine.loader;
 
+import static android.os.Looper.getMainLooper;
 import static junit.framework.TestCase.assertFalse;
 import static junit.framework.TestCase.assertTrue;
+import static org.mockito.Mockito.anyLong;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.robolectric.Shadows.shadowOf;
 
-import io.flutter.FlutterInjector;
-import org.junit.Before;
+import android.app.ActivityManager;
+import android.content.Context;
+import io.flutter.embedding.engine.FlutterJNI;
+import java.util.*;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 
 @Config(manifest = Config.NONE)
 @RunWith(RobolectricTestRunner.class)
 public class FlutterLoaderTest {
-  @Before
-  public void setUp() {
-    FlutterInjector.reset();
-  }
 
   @Test
   public void itReportsUninitializedAfterCreating() {
@@ -31,13 +38,29 @@ public void itReportsUninitializedAfterCreating() {
 
   @Test
   public void itReportsInitializedAfterInitializing() {
-    FlutterInjector.setInstance(new FlutterInjector.Builder().setShouldLoadNative(false).build());
-    FlutterLoader flutterLoader = new FlutterLoader();
+    FlutterJNI.FlutterJNILoader mockFlutterJNILoader = mock(FlutterJNI.FlutterJNILoader.class);
+    FlutterLoader flutterLoader = new FlutterLoader(mockFlutterJNILoader);
 
     assertFalse(flutterLoader.initialized());
     flutterLoader.startInitialization(RuntimeEnvironment.application);
     flutterLoader.ensureInitializationComplete(RuntimeEnvironment.application, null);
+    shadowOf(getMainLooper()).idle();
     assertTrue(flutterLoader.initialized());
-    FlutterInjector.reset();
+    verify(mockFlutterJNILoader, times(1)).loadLibrary();
+
+    ActivityManager activityManager =
+        (ActivityManager) RuntimeEnvironment.application.getSystemService(Context.ACTIVITY_SERVICE);
+    final String oldGenHeapArg = "--old-gen-heap-size=" + activityManager.getLargeMemoryClass();
+    ArgumentCaptor<String[]> shellArgsCaptor = ArgumentCaptor.forClass(String[].class);
+    verify(mockFlutterJNILoader, times(1))
+        .nativeInit(
+            eq(RuntimeEnvironment.application),
+            shellArgsCaptor.capture(),
+            anyString(),
+            anyString(),
+            anyString(),
+            anyLong());
+    List<String> arguments = Arrays.asList(shellArgsCaptor.getValue());
+    assertTrue(arguments.contains(oldGenHeapArg));
   }
 }