Add beginnings of android_apk and unittest_apk templates

build/config/android/internal_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")
 
 assert(is_android)
 
 
 rebased_android_sdk = rebase_path(android_sdk, root_build_dir)
 rebased_android_sdk_root = rebase_path(android_sdk_root, root_build_dir)
 rebased_android_sdk_build_tools = rebase_path(android_sdk_build_tools, root_build_dir)
 
 
 # Write the target's .build_config file. This is a json file that contains a
 # dictionary of information about how to build this target (things that
 # require knowledge about this target's dependencies and cannot be calculated
 # at gn-time). There is a special syntax to add a value in that dictionary to
 # an action/action_foreachs args:
 #   --python-arg=@FileArg($rebased_build_config_path:key0:key1)
 # At runtime, such an arg will be replaced by the value in the build_config.
 # See build/android/gyp/write_build_config.py and
 # build/android/gyp/util/build_utils.py:ExpandFileArgs
 template("write_build_config") {
   assert(defined(invoker.type))
-  assert(defined(invoker.base_path))
+  assert(defined(invoker.build_config))
 
-  base_path = invoker.base_path
   type = invoker.type
-  build_config = base_path + ".build_config"
+  build_config = invoker.build_config
 
-  assert(type == "android_binary" || type == "android_library" || type == "android_resources")
+  assert(type == "android_apk" || type == "android_library" || type == "android_resources")
 
   action(target_name) {
     script = "//build/android/gyp/write_build_config.py"
     depfile = "$target_gen_dir/$target_name.d"
 
     deps = []
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
 
     outputs = [
       depfile,
       build_config
     ]
 
     possible_deps_configs = []
     foreach(d, deps) {
       dep_gen_dir = get_label_info(d, "target_gen_dir")
       dep_name = get_label_info(d, "name")
       possible_deps_configs += [ "$dep_gen_dir/$dep_name.build_config" ]
     }
     rebase_possible_deps_configs = rebase_path(possible_deps_configs)
+
     args = [
       "--type", type,
       "--depfile", rebase_path(depfile, root_build_dir),
       "--possible-deps-configs=$rebase_possible_deps_configs",
       "--build-config", rebase_path(build_config, root_build_dir),
     ]
 
-    if (type == "android_library") {
-      jar_path = base_path + ".jar"
+    if (type == "android_library" || type == "android_apk") {
       args += [
-        "--jar-path", rebase_path(jar_path, root_build_dir),
+        "--jar-path", rebase_path(invoker.jar_path, root_build_dir),
       ]
     }
 
-    if (type == "android_resources") {
+    if (type == "android_resources" || type == "android_apk") {
       assert(defined(invoker.resources_zip))
       args += [
         "--resources-zip", rebase_path(invoker.resources_zip, root_build_dir),
       ]
-      if (defined(invoker.srcjar)) {
-        args += [
-          "--srcjar", rebase_path(invoker.srcjar, root_build_dir)
-        ]
-      }
+    }
+
+    if (defined(invoker.srcjar)) {
+      args += [
+        "--srcjar", rebase_path(invoker.srcjar, root_build_dir)
+      ]
     }
   }
 }
 
 
 # Creates a zip archive of the inputs.
 # If base_dir is provided, the archive paths will be relative to it.
 template("zip") {
   assert(defined(invoker.inputs))
   assert(defined(invoker.output))
@@ skipping 14 matching lines @@
       "--output=$rebase_output",
     ]
     if (defined(invoker.base_dir)) {
       args += [
         "--base-dir", rebase_path(invoker.base_dir, root_build_dir)
       ]
     }
   }
 }
 
-
 # Compiles and jars a set of java files.
 #
 # Outputs:
 #  $jar_path.jar
 #  $jar_path.jar.TOC
 #
 # Variables
 #   java_files: List of .java files to compile.
 #   java_deps: List of java dependencies. These should all have a .jar output
 #     at "${target_gen_dir}/${target_name}.jar.
@@ skipping 98 matching lines @@
   }
 }
 
 
 # This adds Android-specific parts to the java_library template.
 #
 # Runs Android lint against the compiled java files.
 # Dexes the output jar for inclusion in an APK.
 template("android_java_library") {
   assert(defined(invoker.java_files))
-
   assert(defined(invoker.build_config))
   assert(defined(invoker.jar_path))
 
+  jar_path = invoker.jar_path

[newt (away), 2014/07/17 20:11:47]

is jar_path still visible to the java_library template below?

[cjhopman, 2014/07/18 00:58:01]

It is. As discussed, I've changed it to make it more clear what is used where.

+
   java_library("${target_name}__java_library") {
     if (defined(invoker.jar_excluded_patterns)) {
       jar_excluded_patterns = invoker.jar_excluded_patterns
     }
     build_config = invoker.build_config
     java_files = invoker.java_files
-    jar_path = invoker.jar_path
 
     if (defined(invoker.srcjar_deps)) {
       srcjar_deps = invoker.srcjar_deps
     }
   }
 
   # TODO(cjhopman): lint
   # TODO(cjhopman): dex
 
   group(target_name) {
     deps = [
       ":${target_name}__java_library"
     ]
   }
 }
 
 
 # Runs process_resources.py
 template("process_resources") {
   zip_path = invoker.zip_path
   srcjar_path = invoker.srcjar_path
   build_config = invoker.build_config
   resource_dirs = invoker.resource_dirs
   android_manifest = invoker.android_manifest
 
+  non_constant_id = true
+  if (defined(invoker.generate_constant_ids) && invoker.generate_constant_ids) {
+    non_constant_id = false
+  }
+
   action(target_name) {
     script = "//build/android/gyp/process_resources.py"
 
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
       zip_path,
       srcjar_path,
     ]
 
     sources_build_rel = exec_script(
         "//build/android/gyp/find.py",
         rebase_path(resource_dirs, root_build_dir),
         "list lines"
         )
     sources = rebase_path(sources_build_rel, ".", root_build_dir)
 
     source_prereqs = [
       build_config,
       android_manifest,
     ]
 
     rebase_resource_dirs = rebase_path(resource_dirs, root_build_dir)
     rebase_build_config = rebase_path(build_config, root_build_dir)
     args = [
       "--depfile", rebase_path(depfile, root_build_dir),
       "--android-sdk", rebase_path(android_sdk, root_build_dir),
       "--android-sdk-tools", rebase_path(android_sdk_build_tools, root_build_dir),
-      "--non-constant-id",
       "--android-manifest", rebase_path(android_manifest, root_build_dir),
 
       "--resource-dirs=$rebase_resource_dirs",
       "--srcjar-out", rebase_path(srcjar_path, root_build_dir),
       "--resource-zip-out", rebase_path(zip_path, root_build_dir),
 
       "--dependencies-res-zips=@FileArg($rebase_build_config:resources:dependency_zips)",
     ]
 
+    if (non_constant_id) {
+      args += [ "--non-constant-id" ]
+    }
+
     if (defined(invoker.custom_package)) {
       args += [
         "--custom-package", invoker.custom_package,
       ]
     }
 
     if (defined(invoker.v14_verify_only) && invoker.v14_verify_only) {
       args += ["--v14-verify-only"]
     }
+
+    if (defined(invoker.all_resources_zip_path)) {
+      all_resources_zip = invoker.all_resources_zip_path
+      outputs += [ all_resources_zip ]
+      args += [
+        "--all-resources-zip-out", rebase_path(all_resources_zip, root_build_dir)
+      ]
+    }
+
+    if (defined(invoker.args)) {
+      args += invoker.args
+    }
   }
 }