gn format //build

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("//base/android/linker/config.gni")
 import("//build/config/android/config.gni")
 import("//build/config/android/internal_rules.gni")
 import("//tools/grit/grit_rule.gni")
 import("//tools/relocation_packer/config.gni")
 
@@ skipping 12 matching lines @@
 #
 # Example
 #   generate_jni("foo_jni") {
 #     sources = [
 #       "android/java/src/org/chromium/foo/Foo.java",
 #       "android/java/src/org/chromium/foo/FooUtil.java",
 #     ]
 #     jni_package = "foo"
 #   }
 template("generate_jni") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.sources))
   assert(defined(invoker.jni_package))
   jni_package = invoker.jni_package
   base_output_dir = "${target_gen_dir}/${target_name}"
   package_output_dir = "${base_output_dir}/${jni_package}"
   jni_output_dir = "${package_output_dir}/jni"
 
   jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h"
 
   foreach_target_name = "${target_name}__jni_gen"
   action_foreach(foreach_target_name) {
     script = "//base/android/jni_generator/jni_generator.py"
     depfile = "$target_gen_dir/$target_name.{{source_name_part}}.d"
     sources = invoker.sources
-    inputs = [ jni_generator_include ]
+    inputs = [
+      jni_generator_include,
+    ]
     outputs = [
       depfile,
-      "${jni_output_dir}/{{source_name_part}}_jni.h"
+      "${jni_output_dir}/{{source_name_part}}_jni.h",
     ]
 
     args = [
-      "--depfile", rebase_path(depfile, root_build_dir),
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
       "--input_file={{source}}",
       "--optimize_generation=1",
       "--ptr_type=long",
-      "--output_dir", rebase_path(jni_output_dir, root_build_dir),
-      "--includes", rebase_path(jni_generator_include, "//"),
+      "--output_dir",
+      rebase_path(jni_output_dir, root_build_dir),
+      "--includes",
+      rebase_path(jni_generator_include, "//"),
     ]
     if (defined(invoker.jni_generator_jarjar_file)) {
       args += [
-        "--jarjar", rebase_path(jni_generator_jarjar_file, root_build_dir),
+        "--jarjar",
+        rebase_path(jni_generator_jarjar_file, root_build_dir),
       ]
     }
   }
 
   config("jni_includes_${target_name}") {
     # TODO(cjhopman): #includes should probably all be relative to
     # base_output_dir. Remove that from this config once the includes are
     # updated.
     include_dirs = [
       base_output_dir,
       package_output_dir,
     ]
   }
 
   group(target_name) {
-    deps = [ ":$foreach_target_name" ]
+    deps = [
+      ":$foreach_target_name",
+    ]
     public_configs = [ ":jni_includes_${target_name}" ]
 
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
     if (defined(invoker.public_deps)) {
       public_deps = invoker.public_deps
     }
 
-    if (defined(invoker.visibility)) { visibility = invoker.visibility }
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
   }
 }
 
-
 # Declare a jni target for a prebuilt jar
 #
 # This target generates the native jni bindings for a set of classes in a .jar.
 #
 # See base/android/jni_generator/jni_generator.py for more info about the
 # format of generating JNI bindings.
 #
 # Variables
 #   classes: list of .class files in the jar to generate jni for. These should
 #     include the full path to the .class file.
 #   jni_package: subdirectory path for generated bindings
 #   jar_file: the path to the .jar. If not provided, will default to the sdk's
 #     android.jar
 #
 #   deps, public_deps: As normal
 #
 # Example
 #   generate_jar_jni("foo_jni") {
 #     classes = [
 #       "android/view/Foo.class",
 #     ]
 #     jni_package = "foo"
 #   }
 template("generate_jar_jni") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.classes))
   assert(defined(invoker.jni_package))
 
   if (defined(invoker.jar_file)) {
     jar_file = invoker.jar_file
   } else {
     jar_file = android_sdk_jar
   }
 
   jni_package = invoker.jni_package
   base_output_dir = "${root_gen_dir}/${target_name}/${jni_package}"
   jni_output_dir = "${base_output_dir}/jni"
 
   jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h"
 
   # TODO(cjhopman): make jni_generator.py support generating jni for multiple
   # .class files from a .jar.
   jni_actions = []
   foreach(class, invoker.classes) {
     _classname_list = []
-    _classname_list = process_file_template(
-        [class], "{{source_name_part}}")
+    _classname_list = process_file_template([ class ], "{{source_name_part}}")
     classname = _classname_list[0]
     jni_target_name = "${target_name}__jni_${classname}"
     jni_actions += [ ":$jni_target_name" ]
     action(jni_target_name) {
       depfile = "$target_gen_dir/$target_name.d"
       script = "//base/android/jni_generator/jni_generator.py"
       sources = [
         jni_generator_include,
         jar_file,
       ]
       outputs = [
         depfile,
-        "${jni_output_dir}/${classname}_jni.h"
+        "${jni_output_dir}/${classname}_jni.h",
       ]
 
       args = [
-        "--depfile", rebase_path(depfile, root_build_dir),
-        "--jar_file", rebase_path(jar_file, root_build_dir),
-        "--input_file", class,
+        "--depfile",
+        rebase_path(depfile, root_build_dir),
+        "--jar_file",
+        rebase_path(jar_file, root_build_dir),
+        "--input_file",
+        class,
         "--optimize_generation=1",
         "--ptr_type=long",
-        "--output_dir", rebase_path(jni_output_dir, root_build_dir),
-        "--includes", rebase_path(jni_generator_include, root_build_dir),
+        "--output_dir",
+        rebase_path(jni_output_dir, root_build_dir),
+        "--includes",
+        rebase_path(jni_generator_include, root_build_dir),
       ]
     }
   }
 
   config("jni_includes_${target_name}") {
     include_dirs = [ base_output_dir ]
   }
 
   group(target_name) {
     deps = jni_actions
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
     if (defined(invoker.public_deps)) {
       public_deps = invoker.public_deps
     }
     public_configs = [ ":jni_includes_${target_name}" ]
   }
 }
 
-
 # Declare a target for c-preprocessor-generated java files
 #
 # NOTE: For generating Java conterparts to enums prefer using the java_cpp_enum
 #       rule instead.
 #
 # This target generates java files using the host C pre-processor. Each file in
 # sources will be compiled using the C pre-processor. If include_path is
 # specified, it will be passed (with --I) to the pre-processor.
 #
 # This target will create a single .srcjar. Adding this target to an
@@ skipping 16 matching lines @@
 #       "android/java/templates/Foo.template",
 #     ]
 #     inputs = [
 #       "android/java/templates/native_foo_header.h",
 #     ]
 #
 #     package_name = "org/chromium/base/library_loader"
 #     include_path = "android/java/templates"
 #   }
 template("java_cpp_template") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.sources))
   package_name = invoker.package_name + ""
 
   if (defined(invoker.include_path)) {
     include_path = invoker.include_path + ""
   } else {
     include_path = "//"
   }
 
   action_foreach("${target_name}__apply_gcc") {
     script = "//build/android/gyp/gcc_preprocess.py"
     if (defined(invoker.inputs)) {
       inputs = invoker.inputs + []
     }
     depfile = "${target_gen_dir}/${target_name}_{{source_name_part}}.d"
 
     sources = invoker.sources
 
-    gen_dir = "${target_gen_dir}/${target_name}/java_cpp_template/${package_name}"
+    gen_dir =
+        "${target_gen_dir}/${target_name}/java_cpp_template/${package_name}"
     gcc_template_output_pattern = "${gen_dir}/{{source_name_part}}.java"
 
     outputs = [
       depfile,
-      gcc_template_output_pattern
+      gcc_template_output_pattern,
     ]
 
     args = [
-      "--depfile", rebase_path(depfile, root_build_dir),
-      "--include-path", rebase_path(include_path, root_build_dir),
-      "--output", rebase_path(gen_dir, root_build_dir) + "/{{source_name_part}}.java",
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
+      "--include-path",
+      rebase_path(include_path, root_build_dir),
+      "--output",
+      rebase_path(gen_dir, root_build_dir) + "/{{source_name_part}}.java",
       "--template={{source}}",
     ]
 
     if (defined(invoker.defines)) {
       foreach(def, invoker.defines) {
-        args += ["--defines", def]
+        args += [
+          "--defines",
+          def,
+        ]
       }
     }
   }
 
   apply_gcc_outputs = get_target_outputs(":${target_name}__apply_gcc")
   base_gen_dir = get_label_info(":${target_name}__apply_gcc", "target_gen_dir")
 
   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
   zip("${target_name}__zip_srcjar") {
     inputs = apply_gcc_outputs
     output = srcjar_path
     base_dir = base_gen_dir
   }
 
   group(target_name) {
     deps = [
-      ":${target_name}__zip_srcjar"
+      ":${target_name}__zip_srcjar",
     ]
   }
 }
 
 # Declare a target for generating Java classes from C++ enums.
 #
 # This target generates Java files from C++ enums using a script.
 #
 # This target will create a single .srcjar. Adding this target to an
 # android_library target's srcjar_deps will make the generated java files be
@@ skipping 12 matching lines @@
 # Example
 #   java_cpp_enum("foo_generated_enum") {
 #     sources = [
 #       "src/native_foo_header.h",
 #     ]
 #     outputs = [
 #       "org/chromium/FooEnum.java",
 #     ]
 #   }
 template("java_cpp_enum") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.sources))
   assert(defined(invoker.outputs))
 
   action("${target_name}__generate_enum") {
     sources = invoker.sources
     script = "//build/android/gyp/java_cpp_enum.py"
     gen_dir = "${target_gen_dir}/${target_name}/enums"
-    outputs = get_path_info(
-        rebase_path(invoker.outputs, ".", gen_dir), "abspath")
+    outputs =
+        get_path_info(rebase_path(invoker.outputs, ".", gen_dir), "abspath")
 
     args = [
-      "--output_dir", rebase_path(gen_dir, root_build_dir),
+      "--output_dir",
+      rebase_path(gen_dir, root_build_dir),
     ]
     foreach(output, rebase_path(outputs, root_build_dir)) {
-      args += ["--assert_file", output]
+      args += [
+        "--assert_file",
+        output,
+      ]
     }
     args += rebase_path(invoker.sources, root_build_dir)
   }
 
   generate_enum_outputs = get_target_outputs(":${target_name}__generate_enum")
-  base_gen_dir = get_label_info(":${target_name}__generate_enum",
-                                "target_gen_dir")
+  base_gen_dir =
+      get_label_info(":${target_name}__generate_enum", "target_gen_dir")
 
   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
   zip("${target_name}__zip_srcjar") {
     inputs = generate_enum_outputs
     output = srcjar_path
     base_dir = base_gen_dir
   }
 
   group(target_name) {
     deps = [
-      ":${target_name}__zip_srcjar"
+      ":${target_name}__zip_srcjar",
     ]
   }
 }
 
 # Declare a target for processing a Jinja template.
 #
 # Variables
 #   input: The template file to be processed.
 #   output: Where to save the result.
 #   variables: (Optional) A list of variables to make available to the template
 #     processing environment, e.g. ["name=foo", "color=red"].
 #
 # Example
 #   jinja_template("chrome_shell_manifest") {
 #     input = "shell/java/AndroidManifest.xml"
 #     output = "$target_gen_dir/AndroidManifest.xml"
 #   }
 template("jinja_template") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.input))
   assert(defined(invoker.output))
 
   action(target_name) {
-    sources = [invoker.input]
+    sources = [
+      invoker.input,
+    ]
     script = "//build/android/gyp/jinja_template.py"
     depfile = "$target_gen_dir/$target_name.d"
 
     outputs = [
       depfile,
       invoker.output,
     ]
 
     args = [
-      "--inputs", rebase_path(invoker.input, root_build_dir),
-      "--output", rebase_path(invoker.output, root_build_dir),
-      "--depfile", rebase_path(depfile, root_build_dir),
+      "--inputs",
+      rebase_path(invoker.input, root_build_dir),
+      "--output",
+      rebase_path(invoker.output, root_build_dir),
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
     ]
     if (defined(invoker.variables)) {
       variables = invoker.variables
-      args += ["--variables=${variables}" ]
+      args += [ "--variables=${variables}" ]
     }
   }
 }
 
 # Declare a target for processing Android resources as Jinja templates.
 #
 # This takes an Android resource directory where each resource is a Jinja
 # template, processes each template, then packages the results in a zip file
 # which can be consumed by an android resources, library, or apk target.
 #
 # If this target is included in the deps of an android resources/library/apk,
 # the resources will be included with that target.
 #
 # Variables
 #   resources: The list of resources files to process.
 #   res_dir: The resource directory containing the resources.
 #   variables: (Optional) A list of variables to make available to the template
 #     processing environment, e.g. ["name=foo", "color=red"].
 #
 # Example
 #   jinja_template_resources("chrome_shell_template_resources") {
 #     res_dir = "shell/res_template"
 #     resources = ["shell/res_template/xml/syncable.xml"]
 #     variables = ["color=red"]
 #   }
 template("jinja_template_resources") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.resources))
   assert(defined(invoker.res_dir))
 
   _base_path = "$target_gen_dir/$target_name"
   _resources_zip = _base_path + ".resources.zip"
   _build_config = _base_path + ".build_config"
 
   write_build_config("${target_name}__build_config") {
     build_config = _build_config
     resources_zip = _resources_zip
     type = "android_resources"
   }
 
   action("${target_name}__template") {
     sources = invoker.resources
     script = "//build/android/gyp/jinja_template.py"
     depfile = "$target_gen_dir/$target_name.d"
 
     outputs = [
       depfile,
       _resources_zip,
     ]
 
     rebased_resources = rebase_path(invoker.resources, root_build_dir)
     args = [
       "--inputs=${rebased_resources}",
-      "--inputs-base-dir", rebase_path(invoker.res_dir, root_build_dir),
-      "--outputs-zip", rebase_path(_resources_zip, root_build_dir),
-      "--depfile", rebase_path(depfile, root_build_dir),
+      "--inputs-base-dir",
+      rebase_path(invoker.res_dir, root_build_dir),
+      "--outputs-zip",
+      rebase_path(_resources_zip, root_build_dir),
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
     ]
     if (defined(invoker.variables)) {
       variables = invoker.variables
-      args += ["--variables=${variables}" ]
+      args += [ "--variables=${variables}" ]
     }
   }
 
   group(target_name) {
     deps = [
       ":${target_name}__build_config",
       ":${target_name}__template",
     ]
   }
 }
@@ skipping 22 matching lines @@
 #   shared_resources: If true make a resource package that can be loaded by a
 #     different application at runtime to access the package's resources.
 #
 # Example
 #   android_resources("foo_resources") {
 #     deps = [":foo_strings_grd"]
 #     resource_dirs = ["res"]
 #     custom_package = "org.chromium.foo"
 #   }
 template("android_resources") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.resource_dirs))
   assert(defined(invoker.android_manifest) || defined(invoker.custom_package))
 
   base_path = "$target_gen_dir/$target_name"
   zip_path = base_path + ".resources.zip"
   srcjar_path = base_path + ".srcjar"
   build_config = base_path + ".build_config"
 
   write_build_config("${target_name}__build_config") {
     type = "android_resources"
     resources_zip = zip_path
     srcjar = srcjar_path
-    if (defined(invoker.deps)) { deps = invoker.deps }
-    if (defined(invoker.android_manifest)) { android_manifest = invoker.android_manifest }
-    if (defined(invoker.custom_package)) { custom_package = invoker.custom_package }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.android_manifest)) {
+      android_manifest = invoker.android_manifest
+    }
+    if (defined(invoker.custom_package)) {
+      custom_package = invoker.custom_package
+    }
   }
 
   android_manifest = "//build/android/AndroidManifest.xml"
   if (defined(invoker.android_manifest)) {
     android_manifest = invoker.android_manifest
   }
 
   process_resources("${target_name}__process_resources") {
     resource_dirs = invoker.resource_dirs
     if (defined(invoker.custom_package)) {
@@ skipping 10 matching lines @@
   }
 
   group(target_name) {
     deps = [
       ":${target_name}__build_config",
       ":${target_name}__process_resources",
     ]
   }
 }
 
-
 # Declare a target that generates localized strings.xml from a .grd file.
 #
 # If this target is included in the deps of an android resources/library/apk,
 # the strings.xml will be included with that target.
 #
 # Variables
 #   deps: Specifies the dependencies of this target.
 #   grd_file: Path to the .grd file to generate strings.xml from.
 #   outputs: Expected grit outputs (see grit rule).
 #
 # Example
 #  java_strings_grd("foo_strings_grd") {
 #    grd_file = "foo_strings.grd"
 #  }
 template("java_strings_grd") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   base_path = "$target_gen_dir/$target_name"
   resources_zip = base_path + ".resources.zip"
   build_config = base_path + ".build_config"
 
   write_build_config("${target_name}__build_config") {
     type = "android_resources"
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
   }
 
   # Put grit files into this subdirectory of target_gen_dir.
   extra_output_path = target_name + "_grit_output"
 
   grit_target_name = "${target_name}__grit"
   grit_output_dir = "$target_gen_dir/$extra_output_path"
   grit(grit_target_name) {
     grit_flags = [
-      "-E", "ANDROID_JAVA_TAGGED_ONLY=false",
+      "-E",
+      "ANDROID_JAVA_TAGGED_ONLY=false",
     ]
     output_dir = grit_output_dir
     resource_ids = ""
     source = invoker.grd_file
     outputs = invoker.outputs
   }
 
   # This needs to get outputs from grit's internal target, not the final
   # source_set.
   generate_strings_outputs = get_target_outputs(":${grit_target_name}_grit")
@@ skipping 22 matching lines @@
 #  generated_files: list of android resource files to package.
 #
 # Example
 #  java_strings_grd_prebuilt("foo_strings_grd") {
 #    grit_output_dir = "$root_gen_dir/foo/grit"
 #    generated_files = [
 #      "values/strings.xml"
 #    ]
 #  }
 template("java_strings_grd_prebuilt") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   base_path = "$target_gen_dir/$target_name"
   resources_zip = base_path + ".resources.zip"
   build_config = base_path + ".build_config"
 
   write_build_config("${target_name}__build_config") {
     type = "android_resources"
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
@@ skipping 39 matching lines @@
 # Example
 #   java_library("foo") {
 #     java_files = [ "org/chromium/foo/FooMain.java" ]
 #     deps = [ ":bar_java" ]
 #     main_class = "org.chromium.foo.FooMain"
 #   }
 template("java_binary") {
   # TODO(cjhopman): This should not act like a java_library for dependents (i.e.
   # dependents shouldn't get the jar in their classpath, etc.).
   java_library_impl(target_name) {
-    if (defined(invoker.DEPRECATED_java_in_dir)) { DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir }
-    if (defined(invoker.chromium_code)) { chromium_code = invoker.chromium_code }
-    if (defined(invoker.datadeps)) { deps = invoker.datadeps }
-    if (defined(invoker.deps)) { deps = invoker.deps }
-    if (defined(invoker.java_files)) { java_files = invoker.java_files }
-    if (defined(invoker.srcjar_deps)) { srcjar_deps = invoker.srcjar_deps }
-    if (defined(invoker.srcjars)) { srcjars = invoker.srcjars }
-    if (defined(invoker.bypass_platform_checks)) { bypass_platform_checks = invoker.bypass_platform_checks }
-    if (defined(invoker.testonly)) { testonly = invoker.testonly }
+    if (defined(invoker.DEPRECATED_java_in_dir)) {
+      DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
+    }
+    if (defined(invoker.chromium_code)) {
+      chromium_code = invoker.chromium_code
+    }
+    if (defined(invoker.datadeps)) {
+      deps = invoker.datadeps
+    }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.java_files)) {
+      java_files = invoker.java_files
+    }
+    if (defined(invoker.srcjar_deps)) {
+      srcjar_deps = invoker.srcjar_deps
+    }
+    if (defined(invoker.srcjars)) {
+      srcjars = invoker.srcjars
+    }
+    if (defined(invoker.bypass_platform_checks)) {
+      bypass_platform_checks = invoker.bypass_platform_checks
+    }
+    if (defined(invoker.testonly)) {
+      testonly = invoker.testonly
+    }
 
     main_class = invoker.main_class
   }
 }
 
-
 # Declare an java library target
 #
 # Variables
 #   deps: Specifies the dependencies of this target. Java targets in this list
 #     will be added to the javac classpath.
 #
 #   java_files: List of .java files included in this library.
 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 #     will be added to java_files and be included in this library.
 #   srcjars: List of srcjars to be included in this library, together with the
@@ skipping 31 matching lines @@
 #     ]
 #     srcjar_deps = [
 #       ":foo_generated_enum"
 #     ]
 #     jar_excluded_patterns = [
 #       "*/FooService.class", "*/FooService##*.class"
 #     ]
 #   }
 template("java_library") {
   java_library_impl(target_name) {
-    if (defined(invoker.DEPRECATED_java_in_dir)) { DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir }
-    if (defined(invoker.chromium_code)) { chromium_code = invoker.chromium_code }
-    if (defined(invoker.datadeps)) { deps = invoker.datadeps }
-    if (defined(invoker.deps)) { deps = invoker.deps }
-    if (defined(invoker.jar_excluded_patterns)) { jar_excluded_patterns = invoker.jar_excluded_patterns }
-    if (defined(invoker.java_files)) { java_files = invoker.java_files }
-    if (defined(invoker.proguard_config)) { proguard_config = invoker.proguard_config }
-    if (defined(invoker.proguard_preprocess)) { proguard_preprocess = invoker.proguard_preprocess }
-    if (defined(invoker.srcjar_deps)) { srcjar_deps = invoker.srcjar_deps }
-    if (defined(invoker.srcjars)) { srcjars = invoker.srcjars }
-    if (defined(invoker.bypass_platform_checks)) { bypass_platform_checks = invoker.bypass_platform_checks }
-    if (defined(invoker.testonly)) { testonly = invoker.testonly }
-    if (defined(invoker.jar_path)) { jar_path = invoker.jar_path }
+    if (defined(invoker.DEPRECATED_java_in_dir)) {
+      DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
+    }
+    if (defined(invoker.chromium_code)) {
+      chromium_code = invoker.chromium_code
+    }
+    if (defined(invoker.datadeps)) {
+      deps = invoker.datadeps
+    }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.jar_excluded_patterns)) {
+      jar_excluded_patterns = invoker.jar_excluded_patterns
+    }
+    if (defined(invoker.java_files)) {
+      java_files = invoker.java_files
+    }
+    if (defined(invoker.proguard_config)) {
+      proguard_config = invoker.proguard_config
+    }
+    if (defined(invoker.proguard_preprocess)) {
+      proguard_preprocess = invoker.proguard_preprocess
+    }
+    if (defined(invoker.srcjar_deps)) {
+      srcjar_deps = invoker.srcjar_deps
+    }
+    if (defined(invoker.srcjars)) {
+      srcjars = invoker.srcjars
+    }
+    if (defined(invoker.bypass_platform_checks)) {
+      bypass_platform_checks = invoker.bypass_platform_checks
+    }
+    if (defined(invoker.testonly)) {
+      testonly = invoker.testonly
+    }
+    if (defined(invoker.jar_path)) {
+      jar_path = invoker.jar_path
+    }
 
     if (defined(invoker.supports_android) && invoker.supports_android) {
       supports_android = true
     }
   }
 }
 
-
 # Declare an java library target for a prebuilt jar
 #
 # Variables
 #   deps: Specifies the dependencies of this target. Java targets in this list
 #     will be added to the javac classpath.
 #   jar_path: Path to the prebuilt jar.
 #   proguard_preprocess: If true, proguard preprocessing will be run. This can
 #     be used to remove unwanted parts of the library.
 #   proguard_config: Path to the proguard config for preprocessing.
 #
 # Example
 #   java_prebuilt("foo_java") {
 #     jar_path = "foo.jar"
 #     deps = [
 #       ":foo_resources",
 #       ":bar_java"
 #     ]
 #   }
 template("java_prebuilt") {
   java_prebuilt_impl(target_name) {
     jar_path = invoker.jar_path
-    if (defined(invoker.testonly)) { testonly = invoker.testonly }
-    if (defined(invoker.deps)) { deps = invoker.deps }
-    if (defined(invoker.proguard_config)) { proguard_config = invoker.proguard_config }
-    if (defined(invoker.proguard_preprocess)) { proguard_preprocess = invoker.proguard_preprocess }
+    if (defined(invoker.testonly)) {
+      testonly = invoker.testonly
+    }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.proguard_config)) {
+      proguard_config = invoker.proguard_config
+    }
+    if (defined(invoker.proguard_preprocess)) {
+      proguard_preprocess = invoker.proguard_preprocess
+    }
   }
 }
 
 # Declare an Android library target
 #
 # This target creates an Android library containing java code and Android
 # resources.
 #
 # Variables
 #   deps: Specifies the dependencies of this target. Java targets in this list
@@ skipping 30 matching lines @@
 #     ]
 #     srcjar_deps = [
 #       ":foo_generated_enum"
 #     ]
 #     jar_excluded_patterns = [
 #       "*/FooService.class", "*/FooService##*.class"
 #     ]
 #   }
 template("android_library") {
   assert(!defined(invoker.jar_path),
-      "android_library does not support a custom jar path")
+         "android_library does not support a custom jar path")
   java_library_impl(target_name) {
-    if (defined(invoker.DEPRECATED_java_in_dir)) { DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir }
-    if (defined(invoker.chromium_code)) { chromium_code = invoker.chromium_code }
-    if (defined(invoker.datadeps)) { deps = invoker.datadeps }
-    if (defined(invoker.deps)) { deps = invoker.deps }
-    if (defined(invoker.jar_excluded_patterns)) { jar_excluded_patterns = invoker.jar_excluded_patterns }
-    if (defined(invoker.java_files)) { java_files = invoker.java_files }
-    if (defined(invoker.proguard_config)) { proguard_config = invoker.proguard_config }
-    if (defined(invoker.proguard_preprocess)) { proguard_preprocess = invoker.proguard_preprocess }
-    if (defined(invoker.srcjar_deps)) { srcjar_deps = invoker.srcjar_deps }
-    if (defined(invoker.srcjars)) { srcjars = invoker.srcjars }
-    if (defined(invoker.testonly)) { testonly = invoker.testonly }
-    if (defined(invoker.visibility)) { visibility = invoker.visibility }
-    if (defined(invoker.dex_path)) { dex_path = invoker.dex_path }
+    if (defined(invoker.DEPRECATED_java_in_dir)) {
+      DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
+    }
+    if (defined(invoker.chromium_code)) {
+      chromium_code = invoker.chromium_code
+    }
+    if (defined(invoker.datadeps)) {
+      deps = invoker.datadeps
+    }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.jar_excluded_patterns)) {
+      jar_excluded_patterns = invoker.jar_excluded_patterns
+    }
+    if (defined(invoker.java_files)) {
+      java_files = invoker.java_files
+    }
+    if (defined(invoker.proguard_config)) {
+      proguard_config = invoker.proguard_config
+    }
+    if (defined(invoker.proguard_preprocess)) {
+      proguard_preprocess = invoker.proguard_preprocess
+    }
+    if (defined(invoker.srcjar_deps)) {
+      srcjar_deps = invoker.srcjar_deps
+    }
+    if (defined(invoker.srcjars)) {
+      srcjars = invoker.srcjars
+    }
+    if (defined(invoker.testonly)) {
+      testonly = invoker.testonly
+    }
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+    if (defined(invoker.dex_path)) {
+      dex_path = invoker.dex_path
+    }
 
     supports_android = true
     requires_android = true
 
-    if (!defined(jar_excluded_patterns)) { jar_excluded_patterns = [] }
+    if (!defined(jar_excluded_patterns)) {
+      jar_excluded_patterns = []
+    }
     jar_excluded_patterns += [
-      "*/R.class", "*/R##*.class",
-      "*/Manifest.class", "*/Manifest##*.class",
+      "*/R.class",
+      "*/R##*.class",
+      "*/Manifest.class",
+      "*/Manifest##*.class",
     ]
   }
 }
 
 # Declare an Android library target for a prebuilt jar
 #
 # This target creates an Android library containing java code and Android
 # resources.
 #
 # Variables
@@ skipping 11 matching lines @@
 #     deps = [
 #       ":foo_resources",
 #       ":bar_java"
 #     ]
 #   }
 template("android_java_prebuilt") {
   java_prebuilt_impl(target_name) {
     jar_path = invoker.jar_path
     supports_android = true
     requires_android = true
-    if (defined(invoker.testonly)) { testonly = invoker.testonly }
-    if (defined(invoker.deps)) { deps = invoker.deps }
-    if (defined(invoker.proguard_config)) { proguard_config = invoker.proguard_config }
-    if (defined(invoker.proguard_preprocess)) { proguard_preprocess = invoker.proguard_preprocess }
+    if (defined(invoker.testonly)) {
+      testonly = invoker.testonly
+    }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.proguard_config)) {
+      proguard_config = invoker.proguard_config
+    }
+    if (defined(invoker.proguard_preprocess)) {
+      proguard_preprocess = invoker.proguard_preprocess
+    }
   }
 }
 
-
-
 # Declare an Android apk target
 #
 # This target creates an Android APK containing java code, resources, assets,
 # and (possibly) native libraries.
 #
 # Variables
 #   android_manifest: Path to AndroidManifest.xml.
 #   datadeps: List of dependencies needed at runtime. These will be built but
 #     won't change the generated .apk in any way (in fact they may be built
 #     after the .apk is).
@@ skipping 29 matching lines @@
 #       ":foo_resources"
 #     ]
 #     srcjar_deps = [
 #       ":foo_generated_enum"
 #     ]
 #     native_libs = [
 #       native_lib_path
 #     ]
 #   }
 template("android_apk") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
   gen_dir = "$target_gen_dir/$target_name"
   base_path = "$gen_dir/$target_name"
   _build_config = "$base_path.build_config"
   resources_zip_path = "$base_path.resources.zip"
   all_resources_zip_path = "$base_path.resources.all.zip"
   jar_path = "$base_path.jar"
   final_dex_path = "$gen_dir/classes.dex"
   _template_name = target_name
   _final_apk_path = ""
   if (defined(invoker.final_apk_path)) {
     _final_apk_path = invoker.final_apk_path
   } else if (defined(invoker.apk_name)) {
     _final_apk_path = "$root_build_dir/apks/" + invoker.apk_name + ".apk"
   }
-  _dist_jar_path_list = process_file_template(
-      [ _final_apk_path ],
-      "$root_build_dir/test.lib.java/{{source_name_part}}.jar"
-      )
+  _dist_jar_path_list =
+      process_file_template(
+          [ _final_apk_path ],
+          "$root_build_dir/test.lib.java/{{source_name_part}}.jar")
   _dist_jar_path = _dist_jar_path_list[0]
 
   _native_libs = []
 
   _keystore_path = android_default_keystore_path
   _keystore_name = android_default_keystore_name
   _keystore_password = android_default_keystore_password
 
   if (defined(invoker.keystore_path)) {
     _keystore_path = invoker.keystore_path
     _keystore_name = invoker.keystore_name
     _keystore_password = invoker.keystore_password
   }
 
   _srcjar_deps = []
   if (defined(invoker.srcjar_deps)) {
     _srcjar_deps += invoker.srcjar_deps
   }
 
   _load_library_from_apk = false
 
   if (defined(invoker.native_libs)) {
     _use_chromium_linker = false
     if (defined(invoker.use_chromium_linker)) {
-      _use_chromium_linker = (invoker.use_chromium_linker &&
-        chromium_linker_supported)
+      _use_chromium_linker =
+          invoker.use_chromium_linker && chromium_linker_supported
     }
 
     if (defined(invoker.load_library_from_apk) &&
         invoker.load_library_from_apk) {
       _load_library_from_apk = true
-      assert(_use_chromium_linker, "Loading library from the apk requires use" +
-          " of the Chromium linker.")
+      assert(_use_chromium_linker,
+             "Loading library from the apk requires use" +
+                 " of the Chromium linker.")
     }
 
     _enable_relocation_packing = false
     if (defined(invoker.enable_relocation_packing) &&
         invoker.enable_relocation_packing) {
       _enable_relocation_packing = relocation_packing_supported
-      assert(_use_chromium_linker, "Relocation packing requires use of the" +
-          " Chromium linker.")
+      assert(_use_chromium_linker,
+             "Relocation packing requires use of the" + " Chromium linker.")
     }
 
     _native_libs = process_file_template(
-        invoker.native_libs,
-        "$root_build_dir/lib.stripped/{{source_file_part}}")
+            invoker.native_libs,
+            "$root_build_dir/lib.stripped/{{source_file_part}}")
 
     _native_libs_dir = base_path + "/libs"
 
     if (_use_chromium_linker) {
-      _native_libs += [
-        "$root_build_dir/lib.stripped/libchromium_android_linker.so"
-      ]
+      _native_libs +=
+          [ "$root_build_dir/lib.stripped/libchromium_android_linker.so" ]
     }
 
     _enable_relocation_packing = false
     if (_use_chromium_linker && defined(invoker.enable_relocation_packing) &&
         invoker.enable_relocation_packing) {
       _enable_relocation_packing = true
     }
   }
 
   _rebased_build_config = rebase_path(_build_config, root_build_dir)
 
   write_build_config("${_template_name}__build_config") {
     type = "android_apk"
     dex_path = final_dex_path
     resources_zip = resources_zip_path
     build_config = _build_config
 
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
 
     native_libs = _native_libs
   }
 
   final_deps = []
 
-  final_deps += [":${_template_name}__process_resources"]
+  final_deps += [ ":${_template_name}__process_resources" ]
   process_resources("${_template_name}__process_resources") {
     srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
     android_manifest = invoker.android_manifest
-    resource_dirs = ["//build/android/ant/empty/res"]
+    resource_dirs = [ "//build/android/ant/empty/res" ]
     zip_path = resources_zip_path
     generate_constant_ids = true
     build_config = _build_config
   }
-  _srcjar_deps += [":${_template_name}__process_resources"]
+  _srcjar_deps += [ ":${_template_name}__process_resources" ]
 
   if (_native_libs != []) {
     _enable_chromium_linker_tests = false
     if (defined(invoker.enable_chromium_linker_tests)) {
       _enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
     }
 
     _native_lib_version_name = ""
 
     java_cpp_template("${_template_name}__native_libraries_java") {
       package_name = "org/chromium/base/library_loader"
       sources = [
         "//base/android/java/templates/NativeLibraries.template",
       ]
       inputs = [
         _build_config,
       ]
 
       defines = [
         "NATIVE_LIBRARIES_LIST=" +
-          "@FileArg($_rebased_build_config:native:java_libraries_list)",
+            "@FileArg($_rebased_build_config:native:java_libraries_list)",
         "NATIVE_LIBRARIES_VERSION_NUMBER=\"$_native_lib_version_name\"",
       ]
       if (_use_chromium_linker) {
-        defines += ["ENABLE_CHROMIUM_LINKER"]
+        defines += [ "ENABLE_CHROMIUM_LINKER" ]
       }
       if (_load_library_from_apk) {
-        defines += ["ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE"]
+        defines += [ "ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE" ]
       }
       if (_enable_chromium_linker_tests) {
-        defines += ["ENABLE_CHROMIUM_LINKER_TESTS"]
+        defines += [ "ENABLE_CHROMIUM_LINKER_TESTS" ]
       }
     }
     _srcjar_deps += [ ":${_template_name}__native_libraries_java" ]
   }
 
   final_deps += [ ":${_template_name}__java" ]
   java_library_impl("${_template_name}__java") {
     supports_android = true
     requires_android = true
     override_build_config = _build_config
     android_manifest = invoker.android_manifest
     chromium_code = true
     if (defined(invoker.java_files)) {
       java_files = invoker.java_files
     } else if (defined(invoker.DEPRECATED_java_in_dir)) {
       DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
     } else {
       java_files = []
     }
     srcjar_deps = _srcjar_deps
     dex_path = base_path + ".dex.jar"
   }
 
   if (_dist_jar_path != "") {
     final_deps += [ ":${_template_name}__create_dist_jar" ]
+
     # TODO(cjhopman): This is only ever needed to calculate the list of tests to
     # run. See build/android/pylib/instrumentation/test_jar.py. We should be
     # able to just do that calculation at build time instead.
     action("${_template_name}__create_dist_jar") {
       script = "//build/android/gyp/create_dist_jar.py"
       depfile = "$target_gen_dir/$target_name.d"
-      inputs = [ _build_config ]
+      inputs = [
+        _build_config,
+      ]
       outputs = [
         depfile,
         _dist_jar_path,
       ]
       args = [
-        "--depfile", rebase_path(depfile, root_build_dir),
-        "--output", rebase_path(_dist_jar_path, root_build_dir),
+        "--depfile",
+        rebase_path(depfile, root_build_dir),
+        "--output",
+        rebase_path(_dist_jar_path, root_build_dir),
         "--inputs=@FileArg($_rebased_build_config:dist_jar:dependency_jars)",
       ]
       inputs += [ jar_path ]
       _rebased_jar_path = rebase_path([ jar_path ], root_build_dir)
-      args += [
-        "--inputs=$_rebased_jar_path",
-      ]
+      args += [ "--inputs=$_rebased_jar_path" ]
     }
   }
 
-  final_deps += [":${_template_name}__final_dex"]
+  final_deps += [ ":${_template_name}__final_dex" ]
   dex("${_template_name}__final_dex") {
-    deps = [ ":${_template_name}__java" ]
-    sources = [ jar_path ]
-    inputs = [ _build_config ]
+    deps = [
+      ":${_template_name}__java",
+    ]
+    sources = [
+      jar_path,
+    ]
+    inputs = [
+      _build_config,
+    ]
     output = final_dex_path
     dex_arg_key = "${_rebased_build_config}:apk_dex:dependency_dex_files"
     args = [ "--inputs=@FileArg($dex_arg_key)" ]
   }
 
   if (_native_libs != []) {
     action("${_template_name}__prepare_native") {
       script = "//build/android/gyp/pack_arm_relocations.py"
       packed_libraries_dir = "$_native_libs_dir/$android_app_abi"
       depfile = "$target_gen_dir/$target_name.d"
-      outputs = [
-        depfile
-      ]
+      outputs = [ depfile ]
       inputs = [
-        _build_config
+        _build_config,
       ]
       deps = []
       skip_packing_list = [
         "gdbserver",
         "libchromium_android_linker.so",
       ]
 
       enable_packing_arg = 0
       if (_enable_relocation_packing) {
         enable_packing_arg = 1
-        deps += [
-          relocation_packer_target
-        ]
+        deps += [ relocation_packer_target ]
       }
 
       args = [
-        "--depfile", rebase_path(depfile, root_build_dir),
+        "--depfile",
+        rebase_path(depfile, root_build_dir),
         "--enable-packing=$enable_packing_arg",
         "--has-relocations-with-addends=$relocations_have_addends",
         "--exclude-packing-list=$skip_packing_list",
-        "--android-pack-relocations", rebase_path(relocation_packer_exe, root_build_dir),
-        "--android-objcopy", rebase_path(android_objcopy, root_build_dir),
-        "--stripped-libraries-dir", rebase_path(root_build_dir, root_build_dir),
-        "--packed-libraries-dir", rebase_path(packed_libraries_dir, root_build_dir),
+        "--android-pack-relocations",
+        rebase_path(relocation_packer_exe, root_build_dir),
+        "--android-objcopy",
+        rebase_path(android_objcopy, root_build_dir),
+        "--stripped-libraries-dir",
+        rebase_path(root_build_dir, root_build_dir),
+        "--packed-libraries-dir",
+        rebase_path(packed_libraries_dir, root_build_dir),
         "--libraries=@FileArg(${_rebased_build_config}:native:libraries)",
-        "--clear-dir"
+        "--clear-dir",
       ]
 
       if (is_debug) {
         rebased_gdbserver = rebase_path([ android_gdbserver ], root_build_dir)
         inputs += [ android_gdbserver ]
-        args += [
-          "--libraries=$rebased_gdbserver"
-        ]
+        args += [ "--libraries=$rebased_gdbserver" ]
       }
     }
   }
 
-  final_deps += [":${_template_name}__create"]
+  final_deps += [ ":${_template_name}__create" ]
   create_apk("${_template_name}__create") {
     apk_path = _final_apk_path
     android_manifest = invoker.android_manifest
     resources_zip = all_resources_zip_path
     dex_path = final_dex_path
     load_library_from_apk = _load_library_from_apk
 
     version_code = "1"
     if (defined(invoker.version_code)) {
       version_code = invoker.version_code
     }
 
     version_name = "Developer Build"
     if (defined(invoker.version_name)) {
       version_name = invoker.version_name
     }
 
     keystore_name = _keystore_name
     keystore_path = _keystore_path
     keystore_password = _keystore_password
 
     deps = []
     if (defined(invoker.asset_location)) {
       asset_location = invoker.asset_location
+
       # We don't know the exact dependencies that create the assets in
       # |asset_location|; we depend on all caller deps until a better solution
       # is figured out (http://crbug.com/433330).
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
     }
 
     if (_native_libs != []) {
       native_libs_dir = _native_libs_dir
-      deps += [":${_template_name}__prepare_native"]
+      deps += [ ":${_template_name}__prepare_native" ]
     }
   }
 
   group(target_name) {
     deps = final_deps
     if (defined(invoker.datadeps)) {
       # TODO(cjhopman): Fix this when group datadeps works.
       deps += invoker.datadeps
     }
   }
 }
 
-
 # Declare an Android gtest apk
 #
 # This target creates an Android apk for running gtest-based unittests.
 #
 # Variables
 #   deps: Specifies the dependencies of this target. These will be passed to
 #     the underlying android_apk invocation and should include the java and
 #     resource dependencies of the apk.
 #   unittests_dep: This should be the label of the gtest native target. This
 #     target must be defined previously in the same file.
@@ skipping 17 matching lines @@
 
   if (defined(invoker.unittests_binary)) {
     unittests_binary = invoker.unittests_binary
   } else {
     unittests_binary = "lib" + test_suite_name + ".so"
   }
 
   android_apk(target_name) {
     _apk_name = test_suite_name
     final_apk_path = "$root_build_dir/${_apk_name}_apk/${_apk_name}-debug.apk"
-    java_files = [
-      "//testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java"
-    ]
+    java_files =
+        [ "//testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java" ]
     android_manifest = "//testing/android/java/AndroidManifest.xml"
     native_libs = [ unittests_binary ]
-    deps = [ "//base:base_java" ]
+    deps = [
+      "//base:base_java",
+    ]
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
     datadeps = [
       "//tools/android/forwarder2",
       "//tools/android/md5sum",
     ]
   }
 }
 
@@ skipping 10 matching lines @@
 #
 # Example
 #   android_aidl("foo_aidl") {
 #     import_include = "java/src"
 #     sources = [
 #       "java/src/com/foo/bar/FooBarService.aidl",
 #       "java/src/com/foo/bar/FooBarServiceCallback.aidl",
 #     ]
 #   }
 template("android_aidl") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
   aidl_path = "${android_sdk_build_tools}/aidl"
   framework_aidl = "$android_sdk/framework.aidl"
 
   action(target_name) {
     script = "//build/android/gyp/aidl.py"
     sources = invoker.sources
 
     imports = [ framework_aidl ]
     if (defined(invoker.interface_file)) {
       assert(invoker.interface_file != "")
       imports += [ invoker.interface_file ]
     }
 
-    inputs = [
-      aidl_path,
-    ] + imports
+    inputs = [ aidl_path ] + imports
 
     depfile = "${target_gen_dir}/${target_name}.d"
     outputs = [
       depfile,
-      srcjar_path
+      srcjar_path,
     ]
     rebased_imports = rebase_path(imports, root_build_dir)
     args = [
-      "--depfile", rebase_path(depfile, root_build_dir),
-      "--aidl-path", rebase_path(aidl_path, root_build_dir),
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
+      "--aidl-path",
+      rebase_path(aidl_path, root_build_dir),
       "--imports=$rebased_imports",
-      "--srcjar", rebase_path(srcjar_path, root_build_dir),
+      "--srcjar",
+      rebase_path(srcjar_path, root_build_dir),
     ]
     if (defined(invoker.import_include) && invoker.import_include != "") {
       # TODO(cjhopman): aidl supports creating a depfile. We should be able to
       # switch to constructing a depfile for the overall action from that
       # instead of having all the .java files in the include paths as inputs.
-      rebased_import_includes = rebase_path(
-          [invoker.import_include], root_build_dir)
+      rebased_import_includes =
+          rebase_path([ invoker.import_include ], root_build_dir)
       args += [ "--includes=$rebased_import_includes" ]
 
-      _java_files_build_rel = exec_script(
-          "//build/android/gyp/find.py",
-          rebase_path([invoker.import_include], root_build_dir),
-          "list lines"
-          )
+      _java_files_build_rel =
+          exec_script("//build/android/gyp/find.py",
+                      rebase_path([ invoker.import_include ], root_build_dir),
+                      "list lines")
       _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
       inputs += _java_files
     }
     args += rebase_path(sources, root_build_dir)
   }
 }
 
 # Creates a dist directory for a native executable.
 #
 # Running a native executable on a device requires all the shared library
 # dependencies of that executable. To make it easier to install and run such an
 # executable, this will create a directory containing the native exe and all
 # it's library dependencies.
 #
 # Note: It's usually better to package things as an APK than as a native
 # executable.
 #
 # Variables
 #   dist_dir: Directory for the exe and libraries. Everything in this directory
 #     will be deleted before copying in the exe and libraries.
 #   binary: Path to (stripped) executable.
 #
 # Example
 #   create_native_executable_dist("foo_dist") {
 #     dist_dir = "$root_build_dir/foo_dist"
 #     binary = "$root_build_dir/exe.stripped/foo"
 #   }
 template("create_native_executable_dist") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
 
   dist_dir = invoker.dist_dir
   binary = invoker.binary
   final_deps = []
   template_name = target_name
 
-  libraries_list = "${target_gen_dir}/${template_name}_library_dependencies.list"
+  libraries_list =
+      "${target_gen_dir}/${template_name}_library_dependencies.list"
 
   # TODO(gyp)
   #'dependencies': [
   #'<(DEPTH)/build/android/setup.gyp:copy_system_libraries',
   #],
 
   stripped_libraries_dir = "$root_build_dir/lib.stripped"
   final_deps += [ ":${template_name}__find_library_dependencies" ]
   action("${template_name}__find_library_dependencies") {
     script = "//build/android/gyp/write_ordered_libraries.py"
     depfile = "$target_gen_dir/$target_name.d"
     inputs = [
       binary,
       android_readelf,
     ]
     outputs = [
       depfile,
       libraries_list,
     ]
     rebased_binaries = rebase_path([ binary ], root_build_dir)
     args = [
-      "--depfile", rebase_path(depfile, root_build_dir),
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
       "--input-libraries=$rebased_binaries",
-      "--libraries-dir", rebase_path(stripped_libraries_dir, root_build_dir),
-      "--output", rebase_path(libraries_list, root_build_dir),
-      "--readelf", rebase_path(android_readelf, root_build_dir),
+      "--libraries-dir",
+      rebase_path(stripped_libraries_dir, root_build_dir),
+      "--output",
+      rebase_path(libraries_list, root_build_dir),
+      "--readelf",
+      rebase_path(android_readelf, root_build_dir),
     ]
   }
 
   final_deps += [ ":${template_name}__copy_libraries_and_exe" ]
   copy_ex("${template_name}__copy_libraries_and_exe") {
     clear_dir = true
     inputs = [
       binary,
-      libraries_list
+      libraries_list,
     ]
     dest = dist_dir
     rebased_binaries_list = rebase_path([ binary ], root_build_dir)
     rebased_libraries_list = rebase_path(libraries_list, root_build_dir)
     args = [
       "--files=$rebased_binaries_list",
       "--files=@FileArg($rebased_libraries_list:libraries)",
     ]
   }
 
   group(target_name) {
     deps = final_deps
   }
 }
 
-
 # Compile a protocol buffer to java.
 #
 # This generates java files from protocol buffers and creates an Android library
 # containing the classes.
 #
 # Variables
 #   sources: Paths to .proto files to compile.
 #   proto_path: Root directory of .proto files.
 #
 # Example:
 #  proto_java_library("foo_proto_java") {
 #    proto_path = [ "src/foo" ]
 #    sources = [ "$proto_path/foo.proto" ]
 #  }
 template("proto_java_library") {
   _protoc_dep = "//third_party/android_protobuf:android_protoc($host_toolchain)"
   _protoc_out_dir = get_label_info(_protoc_dep, "root_out_dir")
   _protoc_bin = "$_protoc_out_dir/android_protoc"
   _proto_path = invoker.proto_path
 
   _template_name = target_name
 
   action("${_template_name}__protoc_java") {
     srcjar_path = "$target_gen_dir/$target_name.srcjar"
     script = "//build/protoc_java.py"
     deps = [
-      _protoc_dep
+      _protoc_dep,
     ]
     sources = invoker.sources
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
       srcjar_path,
     ]
     args = [
-      "--depfile", rebase_path(depfile, root_build_dir),
-      "--protoc", rebase_path(_protoc_bin, root_build_dir),
-      "--proto-path", rebase_path(_proto_path, root_build_dir),
-      "--srcjar", rebase_path(srcjar_path, root_build_dir),
-    ] + rebase_path(sources, root_build_dir)
+             "--depfile",
+             rebase_path(depfile, root_build_dir),
+             "--protoc",
+             rebase_path(_protoc_bin, root_build_dir),
+             "--proto-path",
+             rebase_path(_proto_path, root_build_dir),
+             "--srcjar",
+             rebase_path(srcjar_path, root_build_dir),
+           ] + rebase_path(sources, root_build_dir)
   }
 
   android_library(target_name) {
     java_files = []
     srcjar_deps = [ ":${_template_name}__protoc_java" ]
     deps = [
       "//third_party/android_protobuf:protobuf_nano_javalib",
     ]
   }
 }
 
 # TODO(GYP): implement this.
 template("uiautomator_test") {
-  if (defined(invoker.testonly)) { testonly = invoker.testonly }
+  if (defined(invoker.testonly)) {
+    testonly = invoker.testonly
+  }
   assert(target_name != "")
   assert(invoker.deps != [] || true)
   group(target_name) {
   }
 }