Reland of Refactor the various locale_paks() templates to be more shared

tools/grit/repack.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("//tools/grit/grit_rule.gni")
 
 # This file defines a template to invoke grit repack in a consistent manner.
 #
 # Parameters:
 #   sources  [required]
 #       List of pak files that need to be combined.
 #
 #   output  [required]
 #       File name (single string) of the output file.
 #
+#   copy_data_to_bundle [optional]
+#       Whether to define a bundle_data() for the resulting pak.
+#
+#   bundle_output [optional]
+#       Path of the file in the application bundle, defaults to
+#       {{bundle_resources_dir}}/{{source_file_part}}.
+#
 #   deps  [optional]
 #   public_deps  [optional]
 #   visibility  [optional]
 #       Normal meaning.
 template("repack") {
-  action(target_name) {
+  _copy_data_to_bundle =
+      defined(invoker.copy_data_to_bundle) && invoker.copy_data_to_bundle
+  _repack_target_name = target_name
+  if (_copy_data_to_bundle) {
+    _repack_target_name = "${target_name}__repack"
+  }
+
+  action(_repack_target_name) {
     forward_variables_from(invoker,
                            [
                              "deps",
                              "public_deps",
                              "testonly",
                              "visibility",
                            ])
+    if (defined(visibility) && _copy_data_to_bundle) {
+      visibility += [ ":${invoker.target_name}" ]
+    }
     assert(defined(invoker.sources), "Need sources for $target_name")
     assert(defined(invoker.output), "Need output for $target_name")
 
     script = "//tools/grit/grit/format/repack.py"
 
     inputs = invoker.sources
     outputs = [
       invoker.output,
     ]
 
     args = []
     if (defined(invoker.repack_whitelist)) {
       inputs += [ invoker.repack_whitelist ]
       _rebased_whitelist = rebase_path(invoker.repack_whitelist)
       args += [ "--whitelist=$_rebased_whitelist" ]
       args += [ "--suppress-removed-key-output" ]
     }
     args += [ rebase_path(invoker.output, root_build_dir) ]
     args += rebase_path(invoker.sources, root_build_dir)
   }
+
+  if (_copy_data_to_bundle) {
+    bundle_data(target_name) {
+      forward_variables_from(invoker,
+                             [
+                               "testonly",
+                               "visibility",
+                             ])
+
+      public_deps = [
+        ":$_repack_target_name",
+      ]
+      sources = [
+        invoker.output,
+      ]
+      if (defined(invoker.bundle_output)) {
+        outputs = [
+          invoker.bundle_output,
+        ]
+      } else {
+        outputs = [
+          "{{bundle_resources_dir}}/{{source_file_part}}",
+        ]
+      }
+    }
+  }
 }
 
-# This template combines repacking resources and defining a bundle_data target
-# to move them to the application bundle. This is mostly useful on iOS.
+# Repacks a set of .pak files for each locale.
 #
 # Parameters:
-#   sources  [required]
-#       List of pak files that need to be combined.
 #
-#   output  [required]
-#       File name (single string) of the output file.
+#   input_locales [required]
+#       List of locale names to use as inputs.
 #
-#   bundle_output [optional]
-#       Path of the file in the application bundle, defaults to
-#       {{bundle_resources_dir}}/{{source_file_part}} if omitted.
+#   output_locales [required]
+#       A list containing the corresponding output names for each of the
+#       input names. Mac and iOS use different names in some cases.
+#
+#   source_patterns [required]
+#       The pattern for pak files which need repacked. The filenames always end
+#       with "${locale}.pak".
+#       E.g.:
+#          ${root_gen_dir}/foo_ expands to ${root_gen_dir}/foo_zh-CN.pak
+#        when locale is zh-CN.
+#
+#   output_dir [optional]
+#       Directory in which to put all pak files.
 #
 #   deps  [optional]
 #   visibility  [optional]
+#   testonly  [optional]
+#   copy_data_to_bundle [optional]
+#   repack_whitelist [optional]
 #       Normal meaning.
-template("repack_and_bundle") {
-  assert(defined(invoker.bundle_output), "Need bundle_output for $target_name")
+template("repack_locales") {
+  # GN can't handle invoker.output_locales[foo] (http://crbug.com/614747).
+  _output_locales = invoker.output_locales
+  if (defined(invoker.output_dir)) {
+    _output_dir = invoker.output_dir
+  } else {
+    if (is_ios) {
+      _output_dir = "$target_gen_dir"
+    } else {
+      _output_dir = "$target_gen_dir/$target_name"
+    }
+  }
 
-  _repack_target_name = target_name + "_repack"
-  _bundle_target_name = target_name
+  # Collects all targets the loop generates.
+  _locale_targets = []
 
-  repack(_repack_target_name) {
-    visibility = [ ":$_bundle_target_name" ]
+  # This loop iterates over the input locales and also keeps a counter so it
+  # can simultaneously iterate over the output locales (using GN's very
+  # limited looping capabilities).
+  _current_index = 0
+  foreach(_input_locale, invoker.input_locales) {
+    _output_locale = _output_locales[_current_index]
+
+    # Compute the name of the target for the current file. Save it for the deps.
+    _current_name = "${target_name}_${_input_locale}"
+    _locale_targets += [ ":$_current_name" ]
+
+    repack(_current_name) {
+      forward_variables_from(invoker,
+                             [
+                               "copy_data_to_bundle",
+                               "bundle_output",
+                               "deps",
+                               "repack_whitelist",
+                               "testonly",
+                             ])
+      visibility = [ ":${invoker.target_name}" ]
+      if (is_ios) {
+        output = "$_output_dir/${_output_locale}.lproj/locale.pak"
+        if (defined(copy_data_to_bundle) && copy_data_to_bundle) {
+          bundle_output =
+              "{{bundle_resources_dir}}/${_output_locale}.lproj/locale.pak"
+        }
+      } else {
+        output = "$_output_dir/${_output_locale}.pak"
+      }
+      set_sources_assignment_filter([])
+      sources = []
+      foreach(_pattern, invoker.source_patterns) {
+        sources += [ "${_pattern}${_input_locale}.pak" ]
+      }
+    }
+
+    _current_index = _current_index + 1
+  }
+
+  # The group that external targets depend on which collects all deps.
+  group(target_name) {
     forward_variables_from(invoker,
                            [
-                             "deps",
-                             "output",
-                             "sources",
+                             "visibility",
                              "testonly",
                            ])
-  }
-
-  bundle_data(_bundle_target_name) {
-    forward_variables_from(invoker,
-                           [
-                             "testonly",
-                             "visibility",
-                           ])
-
-    public_deps = [
-      ":$_repack_target_name",
-    ]
-    sources = [
-      invoker.output,
-    ]
-    if (defined(invoker.bundle_output)) {
-      outputs = [
-        invoker.bundle_output,
-      ]
-    } else {
-      outputs = [
-        "{{bundle_resources_dir}}/{{source_file_part}}",
-      ]
-    }
+    public_deps = _locale_targets
   }
 }