Created @TraceEvent annotation and corresponding processor

When a method has the @TraceEvent annotation, it will be transformed to include
TraceEvent.begin() and TraceEvent.end() at the start and end of the method.
The function body is moved to a new helper method, while the old function's new
body looks like the following:
```
TraceEvent.begin("Foo.bar");
try {
    wrappedByTraceEvent$bar();
    TraceEvent.end("Foo.bar");
} catch (Throwable e) {
    TraceEvent.end("Foo.bar");
    throw e;
}
```

Used the following code to test building various methods:
```
@TraceEvent
public static void basic() {}

@TraceEvent
public void takesArguments(boolean arg1, long arg2, float arg3) {}

@TraceEvent
public int returnsPrimitive(int arg1, byte arg2, Object arg3, TraceEvent arg4) {
    return 10;
}

@TraceEvent
public Object returnsObject(char arg1, short arg2, double arg3) {
    return null;
}

@TraceEvent
public int throwsError() throws Exception {
    throw new Exception();
}
```

Bug: 818267
Change-Id: I11127203662bf84de4a890da29a09676e760e621
Reviewed-on: https://chromium-review.googlesource.com/1066173
Commit-Queue: Tiger Oakes <tigero@google.com>
Reviewed-by: Biao She <bshe@chromium.org>
Reviewed-by: agrieve <agrieve@chromium.org>
Reviewed-by: Eric Stevenson <estevenson@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565624}

base/BUILD.gn

@@ -2827,6 +2827,7 @@ if (is_android) {
       "android/java/src/org/chromium/base/annotations/NativeCall.java",
       "android/java/src/org/chromium/base/annotations/NativeClassQualifiedName.java",
       "android/java/src/org/chromium/base/annotations/RemovableInRelease.java",
+      "android/java/src/org/chromium/base/annotations/TraceEvent.java",
       "android/java/src/org/chromium/base/annotations/UsedByReflection.java",
       "android/java/src/org/chromium/base/library_loader/LegacyLinker.java",
       "android/java/src/org/chromium/base/library_loader/LibraryLoader.java",

base/android/java/src/org/chromium/base/TraceEvent.java

@@ -23,6 +23,14 @@ import org.chromium.base.annotations.MainDex;
  * }
  * }</pre>
  *
+ * If you want to trace an entire method, you can alternatively use the @TraceEvent annotation:
+ * <pre>{@code
+ * @TraceEvent
+ * public void myTracedMethod() {
+ *   // code.
+ * }
+ * }</pre>
+ *
  * It is OK to use tracing before the native library has loaded, in a slightly restricted fashion.
  * @see EarlyTraceEvent for details.
  */

base/android/java/src/org/chromium/base/annotations/TraceEvent.java

+// 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.
+
+package org.chromium.base.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Any method annotated with a @Trace annotation will have its method wrapped
+ * with a call to {@link org.chromium.base.TraceEvent#begin(String)} and
+ * {@link org.chromium.base.TraceEvent#end(String)}.
+ *
+ * <pre>
+ *   class Foo {
+ *     &#64;TraceEvent
+ *     private void bar() {
+ *       doStuff();
+ *     }
+ *   }
+ * </pre>
+ *
+ * Will generate:
+ *
+ * <pre>
+ *   class Foo {
+ *     &#64;TraceEvent
+ *     private void bar() {
+ *       TraceEvent.begin("Foo::bar");
+ *       try {
+ *          doStuff();
+ *          TraceEvent.end("Foo::bar");
+ *       } catch (Throwable e) {
+ *          TraceEvent.end("bar");
+ *          throw e;
+ *       }
+ *     }
+ *   }
+ * </pre>
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface TraceEvent {}
\ No newline at end of file

build/android/bytecode/BUILD.gn

@@ -11,8 +11,10 @@ java_binary("java_bytecode_rewriter") {
   java_files = [
     "java/org/chromium/bytecode/AssertionEnablerClassAdapter.java",
     "java/org/chromium/bytecode/ByteCodeProcessor.java",
+    "java/org/chromium/bytecode/ClassUtils.java",
     "java/org/chromium/bytecode/CustomClassLoaderClassWriter.java",
     "java/org/chromium/bytecode/CustomResourcesClassAdapter.java",
+    "java/org/chromium/bytecode/TraceEventAnnotationClassAdapter.java",
     "java/org/chromium/bytecode/TypeUtils.java",
   ]
   main_class = "org.chromium.bytecode.ByteCodeProcessor"

build/android/bytecode/java/org/chromium/bytecode/ByteCodeProcessor.java

@@ -4,6 +4,7 @@
 
 package org.chromium.bytecode;
 
+import static org.objectweb.asm.ClassReader.EXPAND_FRAMES;
 import static org.objectweb.asm.ClassWriter.COMPUTE_FRAMES;
 
 import org.objectweb.asm.ClassReader;
@@ -60,7 +61,8 @@ class ByteCodeProcessor {
     }
 
     private static void process(String inputJarPath, String outputJarPath, boolean shouldAssert,
-            boolean shouldUseCustomResources, ClassLoader classPathJarsClassLoader) {
+            boolean shouldUseCustomResources, boolean shouldUseTraceEvent,
+            ClassLoader classPathJarsClassLoader) {
         String tempJarPath = outputJarPath + TEMPORARY_FILE_SUFFIX;
         try (ZipInputStream inputStream = new ZipInputStream(
                      new BufferedInputStream(new FileInputStream(inputJarPath)));
@@ -107,7 +109,11 @@ class ByteCodeProcessor {
                     chain = new CustomResourcesClassAdapter(chain, reader.getClassName(),
                             reader.getSuperName(), classPathJarsClassLoader);
                 }
-                reader.accept(chain, 0);
+                if (shouldUseTraceEvent) {
+                    chain = new TraceEventAnnotationClassAdapter(
+                            chain, reader.getClassName(), classPathJarsClassLoader);
+                }
+                reader.accept(chain, EXPAND_FRAMES);
                 byte[] patchedByteCode = writer.toByteArray();
                 writeZipEntry(tempStream, entry.getName(), patchedByteCode);
             }
@@ -155,16 +161,18 @@ class ByteCodeProcessor {
         String outputJarPath = args[1];
         boolean shouldAssert = args[2].equals("--enable-assert");
         boolean shouldUseCustomResources = args[3].equals("--enable-custom-resources");
+        boolean shouldUseTraceEvent = args[4].equals("--enable-trace-event");
 
         // Load all jars that are on the classpath for the input jar for analyzing class hierarchy.
         ClassLoader classPathJarsClassLoader = null;
-        if (shouldUseCustomResources) {
+        if (shouldUseCustomResources || shouldUseTraceEvent) {
             ArrayList<String> classPathJarsPaths = new ArrayList<>();
             classPathJarsPaths.add(inputJarPath);
             classPathJarsPaths.addAll(Arrays.asList(Arrays.copyOfRange(args, 4, args.length)));
             classPathJarsClassLoader = loadJars(classPathJarsPaths);
         }
+
         process(inputJarPath, outputJarPath, shouldAssert, shouldUseCustomResources,
-                classPathJarsClassLoader);
+                shouldUseTraceEvent, classPathJarsClassLoader);
     }
 }

build/android/bytecode/java/org/chromium/bytecode/ClassUtils.java

+// 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.
+
+package org.chromium.bytecode;
+
+import org.objectweb.asm.Type;
+
+import java.lang.reflect.Array;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Utility methods for working with {@link Class}es.
+ */
+public class ClassUtils {
+    private static final Map<Type, Class<?>> PRIMITIVE_CLASSES;
+    static {
+        PRIMITIVE_CLASSES = new HashMap<>();
+        PRIMITIVE_CLASSES.put(Type.BOOLEAN_TYPE, Boolean.TYPE);
+        PRIMITIVE_CLASSES.put(Type.BYTE_TYPE, Byte.TYPE);
+        PRIMITIVE_CLASSES.put(Type.CHAR_TYPE, Character.TYPE);
+        PRIMITIVE_CLASSES.put(Type.DOUBLE_TYPE, Double.TYPE);
+        PRIMITIVE_CLASSES.put(Type.FLOAT_TYPE, Float.TYPE);
+        PRIMITIVE_CLASSES.put(Type.INT_TYPE, Integer.TYPE);
+        PRIMITIVE_CLASSES.put(Type.LONG_TYPE, Long.TYPE);
+        PRIMITIVE_CLASSES.put(Type.SHORT_TYPE, Short.TYPE);
+    }
+
+    private ClassLoader mClassLoader;
+
+    ClassUtils(ClassLoader classLoader) {
+        mClassLoader = classLoader;
+    }
+
+    /**
+     * Loads a class using an internal name (fully qualified name for a type with dots replaced by
+     * slashes) or standard class name with dots.
+     *
+     * @param className name of the class to load
+     * @return Loaded Class object.
+     */
+    public Class<?> loadClass(String className) {
+        try {
+            return mClassLoader.loadClass(className.replace('/', '.'));
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Checks if one class is the subclass of another.
+     *
+     * @return true if candidate is a subclass of other.
+     */
+    public boolean isSubClass(String candidate, String other) {
+        Class<?> candidateClazz = loadClass(candidate);
+        Class<?> parentClazz = loadClass(other);
+        return parentClazz.isAssignableFrom(candidateClazz);
+    }
+
+    /**
+     * Convert from a Java ASM {@link Type} to a Java {@link Class} object.
+     *
+     * @param type Java ASM type that represents a primitive or class (not a method).
+     * @return The resulting Class.
+     */
+    public Class<?> convert(Type type) {
+        if (PRIMITIVE_CLASSES.containsKey(type)) {
+            return PRIMITIVE_CLASSES.get(type);
+        }
+        String className = type.toString();
+
+        // Process arrays
+        if (className.startsWith("[")) {
+            Class<?> innerClass = convert(Type.getType(className.substring(1)));
+            return Array.newInstance(innerClass, 0).getClass();
+        }
+
+        // Remove special characters
+        if (className.startsWith("L") && className.endsWith(";")) {
+            className = className.substring(1, className.length() - 1);
+        }
+
+        return loadClass(className);
+    }
+}

build/android/bytecode/java/org/chromium/bytecode/CustomResourcesClassAdapter.java

@@ -78,14 +78,14 @@ class CustomResourcesClassAdapter extends ClassVisitor {
     private boolean mShouldTransform;
     private String mClassName;
     private String mSuperClassName;
-    private ClassLoader mClassLoader;
+    private ClassUtils mClassUtils;
 
     CustomResourcesClassAdapter(ClassVisitor visitor, String className, String superClassName,
             ClassLoader classLoader) {
         super(ASM5, visitor);
         this.mClassName = className;
         this.mSuperClassName = superClassName;
-        this.mClassLoader = classLoader;
+        this.mClassUtils = new ClassUtils(classLoader);
     }
 
     @Override
@@ -138,31 +138,20 @@ class CustomResourcesClassAdapter extends ClassVisitor {
     }
 
     private boolean superClassIsFrameworkClass() {
-        return loadClass(mSuperClassName).getProtectionDomain().toString().contains("android.jar");
+        return mClassUtils.loadClass(mSuperClassName)
+                .getProtectionDomain()
+                .toString()
+                .contains("android.jar");
     }
 
     private boolean isDescendantOfContext() {
-        return isSubClass(mClassName, CONTEXT);
+        return mClassUtils.isSubClass(mClassName, CONTEXT);
     }
 
     private boolean superClassIsContextWrapper() {
         return mSuperClassName.equals(CONTEXT_WRAPPER);
     }
 
-    private boolean isSubClass(String candidate, String other) {
-        Class<?> candidateClazz = loadClass(candidate);
-        Class<?> parentClazz = loadClass(other);
-        return parentClazz.isAssignableFrom(candidateClazz);
-    }
-
-    private Class<?> loadClass(String className) {
-        try {
-            return mClassLoader.loadClass(className.replace('/', '.'));
-        } catch (ClassNotFoundException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     /**
      * Remaps Resources.getIdentifier() method calls to use BuildHooksAndroid.
      *

build/android/bytecode/java/org/chromium/bytecode/TraceEventAnnotationClassAdapter.java

+// 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.
+
+package org.chromium.bytecode;
+
+import static org.objectweb.asm.Opcodes.ACC_STATIC;
+import static org.objectweb.asm.Opcodes.ALOAD;
+import static org.objectweb.asm.Opcodes.ASM5;
+import static org.objectweb.asm.Opcodes.ASTORE;
+import static org.objectweb.asm.Opcodes.ATHROW;
+import static org.objectweb.asm.Opcodes.GOTO;
+import static org.objectweb.asm.Opcodes.ILOAD;
+import static org.objectweb.asm.Opcodes.INVOKESTATIC;
+import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
+import static org.objectweb.asm.Opcodes.IRETURN;
+import static org.objectweb.asm.Opcodes.ISTORE;
+import static org.objectweb.asm.Opcodes.RETURN;
+
+import static org.chromium.bytecode.TypeUtils.STRING;
+import static org.chromium.bytecode.TypeUtils.VOID;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.util.Arrays;
+
+/**
+ * An ClassVisitor for adding TraceEvent.begin and TraceEvent.end methods to any method with a
+ * @{@link org.chromium.base.annotations.TraceEvent} annotation.
+ */
+class TraceEventAnnotationClassAdapter extends ClassVisitor {
+    private static final String ANNOTATION_STRING = "@org.chromium.base.annotations.TraceEvent";
+    private static final String ANNOTATION_DESCRIPTOR =
+            "Lorg/chromium/base/annotations/TraceEvent;";
+    private static final String TRACE_EVENT_DESCRIPTOR = "org/chromium/base/TraceEvent";
+    private static final String TRACE_EVENT_SIGNATURE = TypeUtils.getMethodDescriptor(VOID, STRING);
+    private static final String THROWABLE_DESCRIPTOR = "java/lang/Throwable";
+    private static final String MOVED_METHOD_PREFIX = "wrappedByTraceEvent$";
+
+    private String mClassName;
+    private ClassUtils mClassUtils;
+    private Class<?> mClass;
+
+    TraceEventAnnotationClassAdapter(
+            ClassVisitor visitor, String className, ClassLoader classLoader) {
+        super(ASM5, visitor);
+        mClassName = className;
+        mClassUtils = new ClassUtils(classLoader);
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName,
+            String[] interfaces) {
+        super.visit(version, access, name, signature, superName, interfaces);
+        mClass = mClassUtils.loadClass(name);
+        mClassName = name;
+    }
+
+    @Override
+    public MethodVisitor visitMethod(final int access, final String name, String desc,
+            String signature, String[] exceptions) {
+        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
+
+        boolean hasAnnotation = checkAnnotation(name, desc);
+        if (!hasAnnotation) {
+            return mv;
+        } else {
+            writeTryFinallyHelper(mv, access, name, desc);
+
+            // Duplicate the method
+            return super.visitMethod(
+                    access, MOVED_METHOD_PREFIX + name, desc, signature, exceptions);
+        }
+    }
+
+    /**
+     * Writes the necessary bytecode for calling TraceEvent methods wrapped in a try-catch block.
+     *
+     * @param mv a newly created method visitor
+     * @param access bit flag representing the access of the method (i.e.: ACC_STATIC, ACC_PUBLIC).
+     * @param name name of the method (i.e.: "foo")
+     * @param descriptor signature of the method (i.e.: "(Ljava/lang/String;)V")
+     */
+    private void writeTryFinallyHelper(
+            MethodVisitor mv, final int access, final String name, String descriptor) {
+        Type[] argTypes = Type.getArgumentTypes(descriptor);
+        Type returnType = Type.getReturnType(descriptor);
+        boolean isStatic = (access & ACC_STATIC) == ACC_STATIC;
+
+        String eventName = mClassName.substring(mClassName.lastIndexOf('/') + 1) + "." + name;
+
+        mv.visitCode();
+        Label start = new Label();
+        Label end = new Label();
+        Label handler = new Label();
+        mv.visitTryCatchBlock(start, end, handler, THROWABLE_DESCRIPTOR);
+
+        // TraceEvent.begin(String)
+        mv.visitLdcInsn(eventName);
+        mv.visitMethodInsn(
+                INVOKESTATIC, TRACE_EVENT_DESCRIPTOR, "begin", TRACE_EVENT_SIGNATURE, false);
+        // try {
+        mv.visitLabel(start);
+        // var valueToReturn = <name>(<desc>)
+        int i = 0;
+        if (!isStatic) {
+            // 0 now is used for `this`
+            mv.visitVarInsn(ALOAD, 0);
+            i = 1;
+        }
+
+        for (Type arg : argTypes) {
+            mv.visitVarInsn(arg.getOpcode(ILOAD), i);
+
+            if (arg.equals(Type.LONG_TYPE)) {
+                i += 2;
+            } else {
+                i++;
+            }
+        }
+        int returnIndex = i + 1;
+
+        String innerName = MOVED_METHOD_PREFIX + name;
+        if (isStatic) {
+            mv.visitMethodInsn(INVOKESTATIC, mClassName, innerName, descriptor, false);
+        } else {
+            mv.visitMethodInsn(INVOKEVIRTUAL, mClassName, innerName, descriptor, false);
+        }
+        if (!returnType.equals(Type.VOID_TYPE)) {
+            mv.visitVarInsn(returnType.getOpcode(ISTORE), returnIndex);
+        }
+        // TraceEvent.end(String)
+        mv.visitLdcInsn(eventName);
+        mv.visitMethodInsn(
+                INVOKESTATIC, TRACE_EVENT_DESCRIPTOR, "end", TRACE_EVENT_SIGNATURE, false);
+        // return valueToReturn
+        if (!returnType.equals(Type.VOID_TYPE)) {
+            mv.visitVarInsn(returnType.getOpcode(ILOAD), returnIndex);
+        }
+        // }
+        mv.visitLabel(end);
+        Label ambientReturn = null;
+        if (!returnType.equals(Type.VOID_TYPE)) {
+            mv.visitInsn(returnType.getOpcode(IRETURN));
+        } else {
+            ambientReturn = new Label();
+            mv.visitJumpInsn(GOTO, ambientReturn);
+        }
+        // catch (Throwable e) {
+        mv.visitLabel(handler);
+        mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {THROWABLE_DESCRIPTOR});
+        mv.visitVarInsn(ASTORE, returnIndex);
+        // TraceEvent.end(String)
+        mv.visitLdcInsn(eventName);
+        mv.visitMethodInsn(
+                INVOKESTATIC, TRACE_EVENT_DESCRIPTOR, "end", TRACE_EVENT_SIGNATURE, false);
+        // throw e;
+        mv.visitVarInsn(ALOAD, returnIndex);
+        mv.visitInsn(ATHROW);
+        // }
+        if (returnType.equals(Type.VOID_TYPE)) {
+            mv.visitLabel(ambientReturn);
+            mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+            mv.visitInsn(RETURN);
+        }
+        int maxStack = Math.max(1, argTypes.length);
+        int maxLocals = returnIndex + 1;
+        mv.visitMaxs(maxStack, maxLocals);
+        mv.visitEnd();
+    }
+
+    /**
+     * Checks if the {@link org.chromium.base.annotations.TraceEvent} annotation is present on the
+     * method with the given name and descriptor inside the currently visited class.
+     *
+     * @param name name of the method, ie: "foo"
+     * @param descriptor describes the method signature, ie: "()V"
+     * @return true if the {@link org.chromium.base.annotations.TraceEvent} annotation is present.
+     */
+    private boolean checkAnnotation(String name, String descriptor) {
+        Class<?>[] parameterTypes = getMethodParameterTypes(descriptor);
+
+        AnnotatedElement method;
+        try {
+            switch (name) {
+                case "<clinit>":
+                    return false;
+                case "<init>":
+                    method = mClass.getDeclaredConstructor(parameterTypes);
+                    break;
+                default:
+                    method = mClass.getDeclaredMethod(name, parameterTypes);
+                    break;
+            }
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+
+        Annotation[] annotations = method.getAnnotations();
+        return Arrays.stream(annotations).anyMatch(a -> a.toString().startsWith(ANNOTATION_STRING));
+    }
+
+    /**
+     * Converts the ASM method descriptor into an array of {@link Class} objects.
+     *
+     * @param descriptor method signature descriptor
+     * @return array of Class objects, where position in the array corresponds to the location
+     * of the argument for the method.
+     */
+    private Class<?>[] getMethodParameterTypes(String descriptor) {
+        Type[] argTypes = Type.getArgumentTypes(descriptor);
+        return Arrays.stream(argTypes).map(mClassUtils::convert).toArray(Class[] ::new);
+    }
+}

build/android/gyp/bytecode_processor.py

@@ -6,7 +6,6 @@
 """Wraps bin/helper/java_bytecode_rewriter and expands @FileArgs."""
 
 import argparse
-import os
 import sys
 
 from util import build_utils
@@ -30,13 +29,15 @@ def main(argv):
                       help='Extra inputs, passed last to the binary script.')
   _AddSwitch(parser, '--enable-custom-resources')
   _AddSwitch(parser, '--enable-assert')
+  _AddSwitch(parser, '--enable-trace-event')
   args = parser.parse_args(argv)
   extra_classpath_jars = []
   for a in args.extra_jars:
     extra_classpath_jars.extend(build_utils.ParseGnList(a))
 
   cmd = [args.script, args.input_jar, args.output_jar, args.enable_assert,
-         args.enable_custom_resources] + extra_classpath_jars
+         args.enable_custom_resources,
+         args.enable_trace_event] + extra_classpath_jars
   build_utils.CheckOutput(cmd)
 
   if args.depfile:

build/config/android/internal_rules.gni

@@ -1244,6 +1244,10 @@ if (enable_java_templates) {
     _enable_custom_resources = defined(invoker.enable_build_hooks_android) &&
                                invoker.enable_build_hooks_android
 
+    _enable_trace_event =
+        defined(invoker.enable_build_hooks) && invoker.enable_build_hooks &&
+        !(defined(invoker.testonly) && invoker.testonly)
+
     _desugar = defined(invoker.supports_android) && invoker.supports_android
     _emma_instrument = invoker.emma_instrument
 
@@ -1270,7 +1274,7 @@ if (enable_java_templates) {
     assert(!defined(invoker.alternative_android_sdk_jar) ||
            invoker.alternative_android_sdk_jar != "")
 
-    if (_enable_assert || _enable_custom_resources) {
+    if (_enable_assert || _enable_custom_resources || _enable_trace_event) {
       _java_bytecode_rewriter_target = "${target_name}__bytecode_rewrite"
       _java_bytecode_rewriter_input_jar = _previous_output_jar
       _java_bytecode_rewriter_output_jar =
@@ -1314,6 +1318,9 @@ if (enable_java_templates) {
         if (_enable_custom_resources) {
           args += [ "--enable-custom-resources" ]
         }
+        if (_enable_trace_event) {
+          args += [ "--enable-trace-event" ]
+        }
         args += [
           "--extra-classpath-jar",
           rebase_path(_android_sdk_jar, root_build_dir),

build/secondary/third_party/android_tools/support/BUILD.gn

@@ -201,6 +201,8 @@ android_aar_prebuilt("android_support_animated_vector_drawable_java") {
 android_aar_prebuilt("android_support_v7_appcompat_java_internal") {
   deps = [
     ":android_support_v4_java",
+    ":android_support_vector_drawable_java",
+    ":android_support_animated_vector_drawable_java",
   ]
   _lib_name = "appcompat-v7"
   aar_path = "$lib_path/$_lib_name/$lib_version/$_lib_name-$lib_version.aar"

third_party/gvr-android-sdk/BUILD.gn

@@ -6,6 +6,7 @@ import("//build/config/android/rules.gni")
 import("//build/config/c++/c++.gni")
 
 android_aar_prebuilt("controller_test_api_java") {
+  testonly = true
   aar_path = "test-libraries/controller_test_api.aar"
   proguard_configs = [ "test-libraries/proguard.txt" ]