Make android_aar_prebuilt() aware of remaining features

build/config/android/rules.gni

 # Copyright 2014 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("//build/config/android/config.gni")
 import("//build/config/android/internal_rules.gni")
 import("//build/config/dcheck_always_on.gni")
 import("//build/toolchain/toolchain.gni")
 
 assert(is_android)
@@ skipping 2588 matching lines @@
   # Declare an Android library target for a prebuilt AAR.
   #
   # This target creates an Android library containing java code and Android
   # resources. For libraries without resources, it will not generate
   # corresponding android_resources targets.
   #
   # Variables
   #   aar_path: Path to the AAR.
   #   proguard_configs: List of proguard configs to use in final apk step for
   #     any apk that depends on this library.
+  #   ignore_aidl: Whether to ignore .aidl files found with the .aar.

[Ian Wen, 2016/09/06 21:38:34]

I feel like once we include an AAR file, we should respect all the possible
features of the file and we shouldn't give us the option to exclude some
features. If these flags are here temporarily, I think it's fine. Otherwise I
would vote for not including targets that we don't use.

Recently I read an article about Yagni rule
(https://drive.google.com/a/google.com/file/d/0B-yWrS8S9kyqQU1VbDF5N3hndW8/view)
and I think it applies here.

"ignore_native_libraries" might be the only exception though, since they
generally are not compiled using the same flow as java.

[agrieve, 2016/09/07 02:19:31]

That's a fair point. I've removed "ignore_resources", and we'll consider the
remaining ones to be temporarily necessary to document the fact that an .aar has
features that are being ignored.

+  #   ignore_assets: Whether to ignore assets found in the .aar.
+  #   ignore_manifest: Whether to ignore merging of AndroidManifest.xml.
+  #   ignore_resources: Whether to ignore resources found in the .aar.
+  #   ignore_native_libraries: Whether to ignore .so files found in the .aar.
   #   TODO(jbudorick@): remove this arguments after crbug.com/522043 is fixed.
   #   requires_android: Whether this target can only be used for compiling Android related targets.
   #
   # Example
   #   android_aar_prebuilt("foo_java") {
   #     aar_path = "foo.aar"
   #   }
   template("android_aar_prebuilt") {
-    assert(defined(invoker.aar_path))
     _output_path = "${target_gen_dir}/${target_name}"
     _unpack_target_name = "${target_name}__unpack_aar"
+    _ignore_aidl = defined(invoker.ignore_aidl) && invoker.ignore_aidl
+    _ignore_assets = defined(invoker.ignore_assets) && invoker.ignore_assets
+    _ignore_manifest =
+        defined(invoker.ignore_manifest) && invoker.ignore_manifest
+    _ignore_resources =
+        defined(invoker.ignore_resources) && invoker.ignore_resources
+    _ignore_native_libraries = defined(invoker.ignore_native_libraries) &&
+                               invoker.ignore_native_libraries
 
     # Scan the AAR file and determine the resources and jar files.
     # Some libraries might not have resources; others might have two jars.
     _scanned_files =
         exec_script("//build/android/gyp/aar.py",
                     [
                       "--input-file",
                       rebase_path(invoker.aar_path, root_build_dir),
                       "--list",
                     ],
                     "scope")
 
+    assert(_ignore_aidl || _scanned_files.aidl == [],
+           "android_aar_prebuilt() aidl not yet supported." +
+               " Implement or use ignore_aidl = true." +
+               " http://crbug.com/644439")
+    assert(_ignore_assets || _scanned_files.assets == [],
+           "android_aar_prebuilt() assets not yet supported." +
+               " Implement or use ignore_assets = true." +
+               " http://crbug.com/643966")
+    assert(_ignore_native_libraries || !_scanned_files.has_native_libraries,
+           "android_aar_prebuilt() with .so files is not supported." +
+               " Use ignore_native_libraries = true to silence this error.")
+    assert(_ignore_manifest || _scanned_files.is_manifest_empty,
+           "android_aar_prebuilt() manifest merging not yet supported and" +
+               " non-trivial AndroidManifest.xml detected." +
+               " Implement or use ignore_manifest = true." +
+               " http://crbug.com/643967")
+    assert(_scanned_files.has_classes_jar || _scanned_files.subjars == [])
+
     action(_unpack_target_name) {
       script = "//build/android/gyp/aar.py"  # Unzips the AAR
       args = [
         "--input-file",
         rebase_path(invoker.aar_path, root_build_dir),
         "--output-dir",
         rebase_path(_output_path, root_build_dir),
         "--extract",
       ]
       inputs = [
         invoker.aar_path,
       ]
       outputs = [
         "${_output_path}/AndroidManifest.xml",
       ]
 
       if (_scanned_files.resources != []) {
         outputs += [ "${_output_path}/R.txt" ]
         outputs += get_path_info(
                 rebase_path(_scanned_files.resources, "", _output_path),
                 "abspath")
       }
-      if (defined(_scanned_files.jars)) {
-        outputs +=
-            get_path_info(rebase_path(_scanned_files.jars, "", _output_path),
-                          "abspath")
+      if (_scanned_files.has_classes_jar) {
+        outputs += [ "${_output_path}/classes.jar" ]
+      }
+      outputs +=
+          get_path_info(rebase_path(_scanned_files.subjars, "", _output_path),
+                        "abspath")
+      if (_scanned_files.has_proguard_flags) {
+        outputs += [ "${_output_path}/proguard.txt" ]
       }
     }
 
-    _resource_targets = []
-
     # Create the android_resources target for resources.
-    if (_scanned_files.resources != []) {
+    if (!_ignore_resources && _scanned_files.resources != []) {
       _res_target_name = "${target_name}__res"
-      _resource_targets += [ ":$_res_target_name" ]
       android_resources(_res_target_name) {
         forward_variables_from(invoker, [ "deps" ])
         if (!defined(deps)) {
           deps = []
         }
         deps += [ ":$_unpack_target_name" ]
         resource_dirs = []
         generated_resource_dirs = [ "${_output_path}/res" ]
         generated_resource_files =
             rebase_path(_scanned_files.resources, "", _output_path)
         android_manifest_dep = ":$_unpack_target_name"
         android_manifest = "${_output_path}/AndroidManifest.xml"
         v14_skip = true
       }
     }
 
-    # Create android_java_prebuilt targets for jar files.
-    _jar_targets = []
-    _counter = 0
-    foreach(jar, _scanned_files.jars) {
-      _counter += 1
-      _current_target = "${target_name}__jar_$_counter"
-      _jar_targets += [ ":$_current_target" ]
+    # Create android_java_prebuilt target for extra jars within jars/.
+    _subjar_targets = []
+    foreach(_jar_subpath, _scanned_files.subjars) {
+      if (!defined(_counter)) {
+        _counter = 0
+      } else {
+        _counter += 1
+      }
+      _labels = _scanned_files.subjar_labels
+      _current_target = "${target_name}__subjar_${_labels[_counter]}"
+      _subjar_targets += [ ":$_current_target" ]
       java_prebuilt(_current_target) {
         forward_variables_from(invoker,
                                [
+                                 "jar_excluded_patterns",
+                                 "requires_android",
+                               ])
+        deps = [
+          ":$_unpack_target_name",
+        ]
+        if (!defined(requires_android)) {
+          requires_android = true
+        }
+        supports_android = true
+        jar_path = "$_output_path/$_jar_subpath"
+      }
+    }
+
+    # Create android_java_prebuilt target for classes.jar.
+    if (_scanned_files.has_classes_jar) {
+      _jar_target_name = "${target_name}__classes"
+      java_prebuilt(_jar_target_name) {
+        forward_variables_from(invoker,
+                               [
                                  "deps",
                                  "input_jars_paths",
                                  "jar_excluded_patterns",
                                  "proguard_configs",
                                  "requires_android",
                                ])
         if (!defined(deps)) {
           deps = []
         }
-        deps += _resource_targets + [ ":$_unpack_target_name" ]
+        deps += _subjar_targets + [ ":$_unpack_target_name" ]
+        if (defined(_res_target_name)) {
+          deps += [ ":$_res_target_name" ]
+        }
         if (!defined(requires_android)) {
           requires_android = true
         }
         supports_android = true
-        jar_path = "${_output_path}/$jar"
+        jar_path = "$_output_path/classes.jar"
+
+        if (_scanned_files.has_proguard_flags) {
+          if (!defined(proguard_configs)) {
+            proguard_configs = []
+          }
+          proguard_configs += [ "$_output_path/proguard.txt" ]
+        }
       }
     }
 
     java_group(target_name) {
-      deps = _resource_targets + _jar_targets
+      deps = []
+      if (defined(_jar_target_name)) {
+        deps += [ ":$_jar_target_name" ]
+
+        # Although subjars are meant to be private, we add them as deps here
+        # because in practice they seem to contain classes required to be in the
+        # classpath.
+        deps += _subjar_targets
+      }
+      if (defined(_res_target_name)) {
+        deps += [ ":$_res_target_name" ]
+      }
     }
   }
 }