ART: Change indentation to 4 spaces in run-test shards 95-99.

Created with
    for testName in \
        `git grep -E '^  public static void main\(String\[\]' \
            -- test/*<i>-*/src/Main.java | \
        sed '-es/\/src\/Main.java:.*//'`; \
    do \
        find $testName/ -type f -name *.java | \
        xargs sed -E '-es/^((  )+)/\1\1/' --in-place ; \
    done
with <i> manually set to 99 down to 95 (stopping when the
change is getting large).

Manually address many long lines and fix other style issues.

Also fix indentation in two files where
    https://android-review.googlesource.com/2300941
just updated previously wrong indentation.

Exclude changes to
    test/595-profile-saving/src/Main.java
because of a conflict in internal.

Test: testrunner.py --host --optimizing
Test: buildbot-build.sh --target
Change-Id: I02fe676f3983610c0cdda1134aee2476f71bc7ce

2 files changed, 105 insertions, 105 deletions

diff --git a/test/497-inlining-and-class-loader/src/Level1.java b/test/497-inlining-and-class-loader/src/Level1.java
index 977af8321e..18f79ceb26 100644
--- a/test/497-inlining-and-class-loader/src/Level1.java
+++ b/test/497-inlining-and-class-loader/src/Level1.java
@@ -15,13 +15,13 @@
  */
 
 public class Level1 {
-  public static void $inline$bar() {
-    Level2.$inline$bar();
-  }
+    public static void $inline$bar() {
+        Level2.$inline$bar();
+    }
 }
 
 class Level2 {
-  public static void $inline$bar() {
-    Main.$noinline$bar();
-  }
+    public static void $inline$bar() {
+        Main.$noinline$bar();
+    }
 }
diff --git a/test/497-inlining-and-class-loader/src/Main.java b/test/497-inlining-and-class-loader/src/Main.java
index 01b4bcd391..66a3f6e785 100644
--- a/test/497-inlining-and-class-loader/src/Main.java
+++ b/test/497-inlining-and-class-loader/src/Main.java
@@ -19,112 +19,112 @@ import java.lang.reflect.Method;
 import java.util.List;
 
 class MyClassLoader extends ClassLoader {
-  MyClassLoader() throws Exception {
-    super(MyClassLoader.class.getClassLoader());
-
-    // Some magic to get access to the pathList field of BaseDexClassLoader.
-    ClassLoader loader = getClass().getClassLoader();
-    Class<?> baseDexClassLoader = loader.getClass().getSuperclass();
-    Field f = baseDexClassLoader.getDeclaredField("pathList");
-    f.setAccessible(true);
-    Object pathList = f.get(loader);
-
-    // Some magic to get access to the dexField field of pathList.
-    f = pathList.getClass().getDeclaredField("dexElements");
-    f.setAccessible(true);
-    dexElements = (Object[]) f.get(pathList);
-    dexFileField = dexElements[0].getClass().getDeclaredField("dexFile");
-    dexFileField.setAccessible(true);
-  }
-
-  Object[] dexElements;
-  Field dexFileField;
-
-  static ClassLoader level1ClassLoader;
-
-  protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
-    if (this != level1ClassLoader) {
-      if (className.equals("Level1")) {
-        return level1ClassLoader.loadClass(className);
-      } else if (className.equals("Level2")) {
-        throw new ClassNotFoundException("None of my methods require Level2!");
-      } else if (!className.equals("LoadedByMyClassLoader")) {
-        // We're only going to handle LoadedByMyClassLoader.
-        return getParent().loadClass(className);
-      }
-    } else {
-      if (className != "Level1" && className != "Level2") {
-        return getParent().loadClass(className);
-      }
+    MyClassLoader() throws Exception {
+        super(MyClassLoader.class.getClassLoader());
+
+        // Some magic to get access to the pathList field of BaseDexClassLoader.
+        ClassLoader loader = getClass().getClassLoader();
+        Class<?> baseDexClassLoader = loader.getClass().getSuperclass();
+        Field f = baseDexClassLoader.getDeclaredField("pathList");
+        f.setAccessible(true);
+        Object pathList = f.get(loader);
+
+        // Some magic to get access to the dexField field of pathList.
+        f = pathList.getClass().getDeclaredField("dexElements");
+        f.setAccessible(true);
+        dexElements = (Object[]) f.get(pathList);
+        dexFileField = dexElements[0].getClass().getDeclaredField("dexFile");
+        dexFileField.setAccessible(true);
     }
 
-    // Mimic what DexPathList.findClass is doing.
-    try {
-      for (Object element : dexElements) {
-        Object dex = dexFileField.get(element);
-        Method method = dex.getClass().getDeclaredMethod(
-            "loadClassBinaryName", String.class, ClassLoader.class, List.class);
-
-        if (dex != null) {
-          Class<?> clazz = (Class<?>)method.invoke(dex, className, this, null);
-          if (clazz != null) {
-            return clazz;
-          }
+    Object[] dexElements;
+    Field dexFileField;
+
+    static ClassLoader level1ClassLoader;
+
+    protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
+        if (this != level1ClassLoader) {
+            if (className.equals("Level1")) {
+                return level1ClassLoader.loadClass(className);
+            } else if (className.equals("Level2")) {
+                throw new ClassNotFoundException("None of my methods require Level2!");
+            } else if (!className.equals("LoadedByMyClassLoader")) {
+                // We're only going to handle LoadedByMyClassLoader.
+                return getParent().loadClass(className);
+            }
+        } else {
+            if (className != "Level1" && className != "Level2") {
+                return getParent().loadClass(className);
+            }
         }
-      }
-    } catch (Exception e) { /* Ignore */ }
-    return null;
-  }
+
+        // Mimic what DexPathList.findClass is doing.
+        try {
+            for (Object element : dexElements) {
+                Object dex = dexFileField.get(element);
+                Method method = dex.getClass().getDeclaredMethod(
+                        "loadClassBinaryName", String.class, ClassLoader.class, List.class);
+
+                if (dex != null) {
+                    Class<?> clazz = (Class<?>) method.invoke(dex, className, this, null);
+                    if (clazz != null) {
+                        return clazz;
+                    }
+                }
+            }
+        } catch (Exception e) { /* Ignore */ }
+        return null;
+    }
 }
 
 class LoadedByMyClassLoader {
-  public static void bar() {
-    Level1.$inline$bar();
-  }
+    public static void bar() {
+        Level1.$inline$bar();
+    }
 }
 
 class Main {
-  public static void main(String[] args) throws Exception {
-    System.loadLibrary(args[0]);
-    // Clone resolved methods, to restore the original version just
-    // before we walk the stack in $noinline$bar.
-    savedResolvedMethods = cloneResolvedMethods(Main.class);
-
-    MyClassLoader o = new MyClassLoader();
-    MyClassLoader.level1ClassLoader = new MyClassLoader();
-    Class<?> foo = o.loadClass("LoadedByMyClassLoader");
-    Method m = foo.getDeclaredMethod("bar");
-    try {
-      m.invoke(null);
-    } catch (Error e) { /* Ignore */ }
-  }
-
-  public static void $inline$bar() {
-  }
-
-  public static void $noinline$bar() {
-    try {
-      // Be evil and clear all dex cache entries.
-      Field f = Class.class.getDeclaredField("dexCache");
-      f.setAccessible(true);
-      Object dexCache = f.get(Main.class);
-      f = dexCache.getClass().getDeclaredField("resolvedTypes");
-      f.setAccessible(true);
-      Object[] array = (Object[]) f.get(dexCache);
-      for (int i = 0; i < array.length; i++) {
-        array[i] = null;
-      }
-      restoreResolvedMethods(Main.class, savedResolvedMethods);
-    } catch (Throwable t) { /* Ignore */ }
-
-    // This will walk the stack, trying to resolve methods in it.
-    // Because we cleared dex cache entries, we will have to find
-    // classes again, which require to use the correct class loader
-    // in the presence of inlining.
-    new Exception().printStackTrace(System.out);
-  }
-  static Object savedResolvedMethods;
-
-  static native Object cloneResolvedMethods(Class<?> cls);
-  static native void restoreResolvedMethods(Class<?> cls, Object saved);
+    public static void main(String[] args) throws Exception {
+        System.loadLibrary(args[0]);
+        // Clone resolved methods, to restore the original version just
+        // before we walk the stack in $noinline$bar.
+        savedResolvedMethods = cloneResolvedMethods(Main.class);
+
+        MyClassLoader o = new MyClassLoader();
+        MyClassLoader.level1ClassLoader = new MyClassLoader();
+        Class<?> foo = o.loadClass("LoadedByMyClassLoader");
+        Method m = foo.getDeclaredMethod("bar");
+        try {
+            m.invoke(null);
+        } catch (Error e) { /* Ignore */ }
+    }
+
+    public static void $inline$bar() {
+    }
+
+    public static void $noinline$bar() {
+        try {
+            // Be evil and clear all dex cache entries.
+            Field f = Class.class.getDeclaredField("dexCache");
+            f.setAccessible(true);
+            Object dexCache = f.get(Main.class);
+            f = dexCache.getClass().getDeclaredField("resolvedTypes");
+            f.setAccessible(true);
+            Object[] array = (Object[]) f.get(dexCache);
+            for (int i = 0; i < array.length; i++) {
+                array[i] = null;
+            }
+            restoreResolvedMethods(Main.class, savedResolvedMethods);
+        } catch (Throwable t) { /* Ignore */ }
+
+        // This will walk the stack, trying to resolve methods in it.
+        // Because we cleared dex cache entries, we will have to find
+        // classes again, which require to use the correct class loader
+        // in the presence of inlining.
+        new Exception().printStackTrace(System.out);
+    }
+    static Object savedResolvedMethods;
+
+    static native Object cloneResolvedMethods(Class<?> cls);
+    static native void restoreResolvedMethods(Class<?> cls, Object saved);
 }