GN: Refactor android rules to use forward_variables_from()

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)
 
 android_sdk_jar = "$android_sdk/android.jar"
 rebased_android_sdk_jar = rebase_path(android_sdk_jar, root_build_dir)
 android_aapt_path = "$rebased_android_sdk_build_tools/aapt"
 
 template("android_lint") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
 
   jar_path = invoker.jar_path
   android_manifest = invoker.android_manifest
   java_files = invoker.java_files
   base_path = "$target_gen_dir/$target_name"
 
   action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "data_deps",
+                             "public_deps",
+                             "testonly",
+                           ])
     script = "//build/android/gyp/lint.py"
     result_path = base_path + "/result.xml"
     config_path = base_path + "/config.xml"
     suppressions_file = "//build/android/lint/suppressions.xml"
     inputs = [
                suppressions_file,
                android_manifest,
                jar_path,
              ] + java_files
 
@@ skipping 13 matching lines @@
       "--product-dir=.",
       "--jar-path",
       rebase_path(jar_path, root_build_dir),
       "--processed-config-path",
       rebase_path(config_path, root_build_dir),
       "--result-path",
       rebase_path(result_path, root_build_dir),
       "--java-files=$rebased_java_files",
       "--enable",
     ]
-
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
-    if (defined(invoker.public_deps)) {
-      public_deps = invoker.public_deps
-    }
-    if (defined(invoker.data_deps)) {
-      data_deps = invoker.data_deps
-    }
   }
 }
 
 template("findbugs") {
   jar_path = invoker.jar_path
 
   build_config = invoker.build_config
 
   action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "testonly",
+                           ])
     script = "//build/android/findbugs_diff.py"
     depfile = "$target_gen_dir/$target_name.d"
     result_path = "$target_gen_dir/$target_name/result.xml"
     exclusions_file = "//build/android/findbugs_filter/findbugs_exclude.xml"
 
     rebased_build_config = rebase_path(build_config, root_build_dir)
 
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
-
-    if (defined(invoker.testonly)) {
-      testonly = invoker.testonly
-    }
-
     inputs = [
       "//build/android/pylib/utils/findbugs.py",
       exclusions_file,
       jar_path,
     ]
 
     outputs = [
       depfile,
       result_path,
     ]
 
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--exclude",
       rebase_path(exclusions_file, root_build_dir),
       "--auxclasspath-gyp",
       "@FileArg($rebased_build_config:javac:classpath)",
       "--output-file",
       rebase_path(result_path, root_build_dir),
       rebase_path(jar_path, root_build_dir),
     ]
   }
 }
 
 template("dex") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
 
   assert(defined(invoker.output))
   action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "inputs",
+                             "sources",
+                             "testonly",
+                           ])
     script = "//build/android/gyp/dex.py"
     depfile = "$target_gen_dir/$target_name.d"
-    if (defined(invoker.sources)) {
-      sources = invoker.sources
-    }
     outputs = [
       depfile,
       invoker.output,
     ]
-    if (defined(invoker.inputs)) {
-      inputs = invoker.inputs
-    }
-
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
 
     rebased_output = rebase_path(invoker.output, root_build_dir)
 
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--android-sdk-tools",
       rebased_android_sdk_build_tools,
       "--dex-path",
       rebased_output,
@@ skipping 10 matching lines @@
     if (defined(invoker.sources)) {
       args += rebase_path(invoker.sources, 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") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
-
   assert(defined(invoker.inputs))
   assert(defined(invoker.output))
 
   rebase_inputs = rebase_path(invoker.inputs, root_build_dir)
   rebase_output = rebase_path(invoker.output, root_build_dir)
   action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "data_deps",
+                             "deps",
+                             "public_deps",
+                             "inputs",
+                             "testonly",
+                             "visibility",
+                           ])
     script = "//build/android/gn/zip.py"
     depfile = "$target_gen_dir/$target_name.d"
-    inputs = invoker.inputs
     outputs = [
       depfile,
       invoker.output,
     ]
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--inputs=$rebase_inputs",
       "--output=$rebase_output",
     ]
     if (defined(invoker.base_dir)) {
       args += [
         "--base-dir",
         rebase_path(invoker.base_dir, root_build_dir),
       ]
     }
-
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
-    if (defined(invoker.public_deps)) {
-      public_deps = invoker.public_deps
-    }
-    if (defined(invoker.data_deps)) {
-      data_deps = invoker.data_deps
-    }
-
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
   }
 }
 
 # 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") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
 
   assert(defined(invoker.type))
   assert(defined(invoker.build_config))
 
   type = invoker.type
   build_config = invoker.build_config
 
   assert(type == "android_apk" || type == "java_library" ||
          type == "android_resources" || type == "deps_dex")
 
   action(target_name) {
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
+    deps = []
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "testonly",
+                             "visibility",
+                           ])
 
     script = "//build/android/gyp/write_build_config.py"
     depfile = "$target_gen_dir/$target_name.d"
     inputs = []
 
-    deps = []
-    if (defined(invoker.deps)) {
-      deps += invoker.deps
-    }
-
     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, root_build_dir)
 
     outputs = [
@@ skipping 114 matching lines @@
       args += [
         "--srcjar",
         rebase_path(invoker.srcjar, root_build_dir),
       ]
     }
   }
 }
 
 template("process_java_prebuilt") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
+  forward_variables_from(invoker, [ "testonly" ])
 
   _input_jar_path = invoker.input_jar_path
   _output_jar_path = invoker.output_jar_path
   _jar_toc_path = _output_jar_path + ".TOC"
 
   assert(invoker.build_config != "")
 
   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
     _proguard_jar_path = "$android_sdk_root/tools/proguard/lib/proguard.jar"
     _proguard_config_path = invoker.proguard_config
     _build_config = invoker.build_config
     _rebased_build_config = rebase_path(_build_config, root_build_dir)
     _output_jar_target = "${target_name}__proguard_process"
     action(_output_jar_target) {
+      forward_variables_from(invoker,
+                             [
+                               "data_deps",
+                               "deps",
+                               "public_deps",
+                             ])
       script = "//build/android/gyp/proguard.py"
       inputs = [
         android_sdk_jar,
         _proguard_jar_path,
         _build_config,
         _input_jar_path,
         _proguard_config_path,
       ]
       depfile = "${target_gen_dir}/${target_name}.d"
       outputs = [
         depfile,
         _output_jar_path,
       ]
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         "--proguard-path",
         rebase_path(_proguard_jar_path, root_build_dir),
         "--input-path",
         rebase_path(_input_jar_path, root_build_dir),
         "--output-path",
         rebase_path(_output_jar_path, root_build_dir),
         "--proguard-config",
         rebase_path(_proguard_config_path, root_build_dir),
         "--classpath",
         rebased_android_sdk_jar,
         "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
       ]
-
-      if (defined(invoker.deps)) {
-        deps = invoker.deps
-      }
-      if (defined(invoker.public_deps)) {
-        public_deps = invoker.public_deps
-      }
-      if (defined(invoker.data_deps)) {
-        data_deps = invoker.data_deps
-      }
     }
   } else {
     _output_jar_target = "${target_name}__copy_jar"
     copy(_output_jar_target) {
+      forward_variables_from(invoker,
+                             [
+                               "data_deps",
+                               "deps",
+                               "public_deps",
+                             ])
       sources = [
         _input_jar_path,
       ]
       outputs = [
         _output_jar_path,
       ]
-
-      if (defined(invoker.deps)) {
-        deps = invoker.deps
-      }
-      if (defined(invoker.public_deps)) {
-        public_deps = invoker.public_deps
-      }
-      if (defined(invoker.data_deps)) {
-        data_deps = invoker.data_deps
-      }
     }
   }
 
   action("${target_name}__jar_toc") {
     script = "//build/android/gyp/jar_toc.py"
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
       _jar_toc_path,
       _jar_toc_path + ".md5.stamp",
     ]
     inputs = [
       _output_jar_path,
     ]
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--jar-path",
       rebase_path(_output_jar_path, root_build_dir),
       "--toc-path",
       rebase_path(_jar_toc_path, root_build_dir),
     ]
     public_deps = [
       ":$_output_jar_target",
     ]
   }
 
   group(target_name) {
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
+    forward_variables_from(invoker, [ "visibility" ])
     public_deps = [
       ":${target_name}__jar_toc",
       ":$_output_jar_target",
     ]
   }
 }
 
 template("finalize_apk") {
   action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "data_deps",
+                             "deps",
+                             "public_deps",
+                             "testonly",
+                           ])
     script = "//build/android/gyp/finalize_apk.py"
     depfile = "$target_gen_dir/$target_name.d"
 
-    if (defined(invoker.testonly)) {
-      testonly = invoker.testonly
-    }
-
     sources = [
       invoker.input_apk_path,
     ]
     inputs = [
       invoker.keystore_path,
     ]
     outputs = [
       depfile,
       invoker.output_apk_path,
     ]
@@ skipping 16 matching lines @@
     ]
     if (defined(invoker.rezip_apk) && invoker.rezip_apk) {
       _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
       inputs += [ _rezip_jar_path ]
       args += [
         "--load-library-from-zip=1",
         "--rezip-apk-jar-path",
         rebase_path(_rezip_jar_path, root_build_dir),
       ]
     }
-
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
-    if (defined(invoker.public_deps)) {
-      public_deps = invoker.public_deps
-    }
-    if (defined(invoker.data_deps)) {
-      data_deps = invoker.data_deps
-    }
   }
 }
 
 # Packages resources, assets, dex, and native libraries into an apk. Signs and
 # zipaligns the apk.
 template("create_apk") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
+  forward_variables_from(invoker, [ "testonly" ])
 
   _android_manifest = invoker.android_manifest
   _base_path = invoker.base_path
   _final_apk_path = invoker.apk_path
 
   if (defined(invoker.resources_zip)) {
     _resources_zip = invoker.resources_zip
   }
   if (defined(invoker.dex_path)) {
     _dex_path = invoker.dex_path
@@ skipping 231 matching lines @@
     _final_deps += [ ":$_split_rule" ]
   }
 
   group(target_name) {
     public_deps = _final_deps
   }
 }
 
 template("java_prebuilt_impl") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
+  forward_variables_from(invoker, [ "testonly" ])
   _supports_android =
       defined(invoker.supports_android) && invoker.supports_android
 
   assert(defined(invoker.jar_path))
   _base_path = "${target_gen_dir}/$target_name"
   _jar_path = _base_path + ".jar"
   _build_config = _base_path + ".build_config"
 
   if (_supports_android) {
     _dex_path = _base_path + ".dex.jar"
@@ skipping 51 matching lines @@
     dex(dex_target_name) {
       sources = [
         _jar_path,
       ]
       output = _dex_path
       deps = [ ":$process_jar_target_name" ] + _deps + _jar_deps
     }
   }
 
   group(target_name) {
+    forward_variables_from(invoker, [ "data_deps" ])
     deps = [
       ":$process_jar_target_name",
     ]
-    if (defined(invoker.data_deps)) {
-      data_deps = invoker.data_deps
-    }
     if (_supports_android) {
       deps += [ ":$dex_target_name" ]
     }
   }
 }
 
 # 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.
 #   chromium_code: If true, enable extra warnings.
 #   srcjar_deps: List of srcjar dependencies. The .java files contained in the
 #     dependencies srcjar outputs will be compiled and added to the output jar.
 #   jar_path: Use this to explicitly set the output jar path. Defaults to
 #     "${target_gen_dir}/${target_name}.jar.
 template("compile_java") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
+  forward_variables_from(invoker, [ "testonly" ])
 
   assert(defined(invoker.java_files))
   assert(defined(invoker.build_config))
   assert(defined(invoker.jar_path))
 
   _java_files = invoker.java_files
   _final_jar_path = invoker.jar_path
   _intermediate_jar_path = "$target_gen_dir/$target_name.initial.jar"
 
   _build_config = invoker.build_config
@@ skipping 110 matching lines @@
     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
       proguard_preprocess = invoker.proguard_preprocess
       proguard_config = invoker.proguard_config
     }
     deps = [
       ":$javac_target_name",
     ]
   }
 
   group(final_target_name) {
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
+    forward_variables_from(invoker, [ "visibility" ])
     public_deps = [
       ":$finish_target_name",
     ]
   }
 }
 
 template("java_library_impl") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
+  forward_variables_from(invoker, [ "testonly" ])
 
   assert(
       defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir) ||
       defined(invoker.srcjars) || defined(invoker.srcjar_deps))
   _base_path = "$target_gen_dir/$target_name"
   _jar_path = _base_path + ".jar"
   if (defined(invoker.jar_path)) {
     _jar_path = invoker.jar_path
   }
   _template_name = target_name
@@ skipping 27 matching lines @@
            "If you specify a build config file for " +
                "java_library_impl($target_name), you should " +
                "also specify the target that made it in the deps")
     build_config_deps = invoker.deps
   } else {
     _build_config = _base_path + ".build_config"
     build_config_target_name = "${_template_name}__build_config"
     build_config_deps = [ ":$build_config_target_name" ]
 
     write_build_config(build_config_target_name) {
+      forward_variables_from(invoker, [ "deps" ])
       type = "java_library"
       supports_android = _supports_android
       requires_android = _requires_android
       bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
                                invoker.bypass_platform_checks
 
-      deps = []
-      if (defined(invoker.deps)) {
-        deps += invoker.deps
-      }
-
       build_config = _build_config
       jar_path = _jar_path
       if (_supports_android) {
         dex_path = _dex_path
       }
     }
   }
 
   _chromium_code = true
   if (defined(invoker.chromium_code)) {
@@ skipping 30 matching lines @@
               rebase_path(invoker.DEPRECATED_java_in_dir, root_build_dir),
             ],
             "list lines")
     _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
   }
   assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
 
   _compile_java_target = "${_template_name}__compile_java"
   _final_deps += [ ":$_compile_java_target" ]
   compile_java(_compile_java_target) {
+    forward_variables_from(invoker,
+                           [
+                             "dist_jar_path",
+                             "enable_errorprone",
+                             "jar_excluded_patterns",
+                             "manifest_entries",
+                             "proguard_config",
+                             "proguard_preprocess",
+                           ])
     jar_path = _jar_path
     build_config = _build_config
     java_files = _java_files
     srcjar_deps = _srcjar_deps
     srcjars = _srcjars
     chromium_code = _chromium_code
     android = _requires_android
 
-    if (defined(invoker.enable_errorprone)) {
-      enable_errorprone = invoker.enable_errorprone
-    }
-    if (defined(invoker.jar_excluded_patterns)) {
-      jar_excluded_patterns = invoker.jar_excluded_patterns
-    }
-    if (defined(invoker.proguard_preprocess)) {
-      proguard_preprocess = invoker.proguard_preprocess
-    }
-    if (defined(invoker.proguard_config)) {
-      proguard_config = invoker.proguard_config
-    }
-    if (defined(invoker.dist_jar_path)) {
-      dist_jar_path = invoker.dist_jar_path
-    }
-    if (defined(invoker.manifest_entries)) {
-      manifest_entries = invoker.manifest_entries
-    }
-
     supports_android = _supports_android
     deps = build_config_deps
   }
 
   if (defined(invoker.main_class)) {
     _final_deps += [ ":${_template_name}__binary_script" ]
     action("${_template_name}__binary_script") {
       script = "//build/android/gyp/create_java_binary_script.py"
       depfile = "$target_gen_dir/$target_name.d"
       java_script = "$root_build_dir/bin/$_template_name"
@@ skipping 57 matching lines @@
         _jar_path,
       ]
       output = _dex_path
       deps = [
         ":$_compile_java_target",
       ]
     }
   }
 
   group(target_name) {
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
+    forward_variables_from(invoker, [ "visibility" ])
     public_deps = _final_deps
     data_deps = _final_datadeps
   }
 }
 
 # Runs process_resources.py
 template("process_resources") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
+  forward_variables_from(invoker, [ "testonly" ])
 
   zip_path = invoker.zip_path
   srcjar_path = invoker.srcjar_path
   r_text_path = invoker.r_text_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) {
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
-
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "visibility",
+                           ])
     script = "//build/android/gyp/process_resources.py"
 
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
       zip_path,
       srcjar_path,
       r_text_path,
     ]
 
@@ skipping 59 matching lines @@
       outputs += [ all_resources_zip ]
       args += [
         "--all-resources-zip-out",
         rebase_path(all_resources_zip, root_build_dir),
       ]
     }
 
     if (defined(invoker.args)) {
       args += invoker.args
     }
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
   }
 }
 
 template("copy_ex") {
   set_sources_assignment_filter([])
-  if (defined(invoker.testonly)) {
-    testonly = invoker.testonly
-  }
-
   action(target_name) {
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
-
+    inputs = []
+    sources = []
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "inputs",
+                             "sources",
+                             "testonly",
+                             "visibility",
+                           ])
     script = "//build/android/gyp/copy_ex.py"
 
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
-
-    sources = []
-    if (defined(invoker.sources)) {
-      sources += invoker.sources
-    }
-
-    inputs = []
-    if (defined(invoker.inputs)) {
-      inputs += invoker.inputs
-    }
-
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
     ]
 
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--dest",
       rebase_path(invoker.dest, root_build_dir),
@@ skipping 11 matching lines @@
   }
 }
 
 # Produces a single .dex.jar out of a set of Java dependencies.
 template("deps_dex") {
   set_sources_assignment_filter([])
   build_config = "$target_gen_dir/${target_name}.build_config"
   build_config_target_name = "${target_name}__build_config"
 
   write_build_config(build_config_target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "dex_path",
+                           ])
     type = "deps_dex"
-    deps = invoker.deps
-
     build_config = build_config
-    dex_path = invoker.dex_path
   }
 
   rebased_build_config = rebase_path(build_config, root_build_dir)
   dex(target_name) {
     inputs = [
       build_config,
     ]
     output = invoker.dex_path
     dex_arg_key = "${rebased_build_config}:final_dex:dependency_dex_files"
     args = [ "--inputs=@FileArg($dex_arg_key)" ]
     if (defined(invoker.excluded_jars)) {
       excluded_jars = rebase_path(invoker.excluded_jars, root_build_dir)
       args += [ "--excluded-paths=${excluded_jars}" ]
     }
     deps = [
       ":$build_config_target_name",
     ]
   }
 }
 
 # Creates an AndroidManifest.xml for an APK split.
 template("generate_split_manifest") {
   assert(defined(invoker.main_manifest))
   assert(defined(invoker.out_manifest))
   assert(defined(invoker.split_name))
 
   action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "deps",
+                             "testonly",
+                           ])
     depfile = "$target_gen_dir/$target_name.d"
-    if (defined(invoker.deps)) {
-      deps = invoker.deps
-    }
     args = [
       "--main-manifest",
       rebase_path(invoker.main_manifest, root_build_dir),
       "--out-manifest",
       rebase_path(invoker.out_manifest, root_build_dir),
       "--split",
       invoker.split_name,
     ]
     if (defined(invoker.version_code)) {
       args += [
@@ skipping 75 matching lines @@
     ]
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--script-output-path",
       rebase_path(generated_script, root_build_dir),
     ]
     args += test_runner_args
   }
 }