Upstream: DexOptimizer and DexLoader classes

chrome/android/webapk/shell_apk/src/org/chromium/webapk/shell_apk/DexLoader.java

+// Copyright 2016 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.
+
+package org.chromium.webapk.shell_apk;
+
+import android.content.Context;
+import android.util.Log;
+
+import dalvik.system.BaseDexClassLoader;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Creates ClassLoader for .dex file in a remote Context's APK.
+ */
+public class DexLoader {
+    private static final int BUFFER_SIZE = 16 * 1024;
+    private static final String TAG = "cr.DexLoader";
+
+    /**
+     * Creates ClassLoader for .dex file in {@link remoteContext}'s APK.
+     * @param remoteContext The context with the APK with the .dex file.
+     * @param dexName The name of the .dex file in the APK.
+     * @param canaryClassName Name of class in the .dex file. Used for testing the ClassLoader
+     *                        before returning it.
+     * @param remoteDexFile Location of already extracted .dex file from APK.
+     * @param localDexDir Writable directory for caching data to speed up future calls to
+     *                    {@link #load()}.
+     * @return The ClassLoader. Returns null on an error.
+     */
+    public static ClassLoader load(Context remoteContext, String dexName, String canaryClassName,
+            File remoteDexFile, File localDexDir) {
+        File localDexFile = new File(localDexDir, dexName);
+
+        // If {@link localDexFile} exists, technique #2 was previously used to create the
+        // ClassLoader. Skip right to the technique which worked last time.
+        if (remoteDexFile != null && remoteDexFile.exists() && !localDexFile.exists()) {
+            // Technique #1: At startup, Chrome code extracts the .dex file from its assets and
+            // guesses where DexClassLoader searches for the odex by default and puts the odex
+            // there. Try using the odex from Chrome's data directory.
+            ClassLoader loader = tryCreatingClassLoader(canaryClassName, remoteDexFile, null);
+            if (loader != null) {
+                return loader;
+            }
+        }
+
+        // Technique #2: Extract the .dex file from the remote context's APK. Create a
+        // ClassLoader from the extracted file.
+        if (!localDexFile.exists() || localDexFile.length() == 0) {
+            if (!localDexDir.exists() && !localDexDir.mkdirs()) {
+                return null;
+            }
+
+            InputStream inputStream;
+            try {
+                inputStream = remoteContext.getAssets().open(dexName);
+            } catch (Exception e) {
+                Log.w(TAG, "Could not extract dex from assets");
+                e.printStackTrace();
+                return null;
+            }
+            copyFromInputStream(inputStream, localDexFile);
+        }
+
+        File localOptimizedDir = new File(localDexDir, "optimized");
+        if (!localOptimizedDir.exists() && !localOptimizedDir.mkdirs()) {
+            return null;
+        }
+
+        return tryCreatingClassLoader(canaryClassName, localDexFile, localOptimizedDir);
+    }
+
+    /**
+     * Deletes any files cached by {@link #load()}.
+     * @param localDexDir Cache directory passed to {@link #load()}.
+     */
+    public static void deleteCachedDexes(File localDexDir) {
+        deleteChildren(localDexDir);
+    }
+
+    /**
+     * Deletes all of a directory's children including subdirectories.
+     * @param parentDir Directory whose children should be deleted.
+     */
+    private static void deleteChildren(File parentDir) {
+        if (!parentDir.isDirectory()) {
+            return;
+        }
+
+        File[] files = parentDir.listFiles();
+        if (files != null) {
+            for (File file : files) {
+                deleteChildren(file);
+                if (!file.delete()) {
+                    Log.e(TAG, "Could not delete " + file.getPath());
+                }
+            }
+        }
+    }
+
+    /**
+     * Copies an InputStream to a file.
+     * @param inputStream
+     * @param outFile The destination file.
+     */
+    private static void copyFromInputStream(InputStream inputStream, File outFile) {
+        try (FileOutputStream outputStream = new FileOutputStream(outFile)) {
+            byte[] buffer = new byte[BUFFER_SIZE];
+            int count = 0;
+            while ((count = inputStream.read(buffer, 0, BUFFER_SIZE)) != -1) {
+                outputStream.write(buffer, 0, count);
+            }
+        } catch (IOException e) {
+        } finally {
+            try {
+                inputStream.close();
+            } catch (Exception e) {
+            }
+        }
+    }
+
+    /**
+     * Tries to create ClassLoader with the given .dex file and optimized dex directory.
+     * @param canaryClassName Name of class in the .dex file. Used for testing the ClassLoader
+     *                        before returning it.
+     * @param dexFile .dex file to create ClassLoader for.
+     * @param optimizedDir Directory for storing the optimized dex file. If null, an OS-defined
+     *                     path based on {@link dexFile} is used.
+     * @return The ClassLoader. Returns null on an error.
+     */
+    private static ClassLoader tryCreatingClassLoader(
+            String canaryClassName, File dexFile, File optimizedDir) {
+        try {
+            ClassLoader loader = new BaseDexClassLoader(
+                    dexFile.getPath(), optimizedDir, null, ClassLoader.getSystemClassLoader());
+            // Loading {@link canaryClassName} will throw an exception if the .dex file cannot be
+            // loaded.
+            loader.loadClass(canaryClassName);
+            return loader;
+        } catch (Exception e) {
+            String optimizedDirPath = (optimizedDir == null) ? null : optimizedDir.getPath();
+            Log.w(TAG, "Could not load dex from " + dexFile.getPath() + " with optimized directory "
+                            + optimizedDirPath);
+            e.printStackTrace();
+            return null;
+        }
+    }
+}