Mojo JS bindings: introduce new targets "foo_js"/"foo_js_data_deps" for mojom("foo").

mojo/public/tools/bindings/mojom.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.
 
 declare_args() {
   # Indicates whether typemapping should be supported in this build
   # configuration. This may be disabled when building external projects which
   # depend on //mojo but which do not need/want all of the Chromium tree
   # dependencies that come with typemapping.
   #
@@ skipping 83 matching lines @@
 }
 
 # Generates targets for building C++, JavaScript and Java bindings from mojom
 # files. The output files will go under the generated file directory tree with
 # the same path as each input file.
 #
 # Other targets should depend on one of these generated targets (where "foo"
 # is the target name):
 #
 #   foo
-#       C++ and Javascript bindings. Other mojom targets should also depend on
-#       this target.
+#       C++ bindings.
 #
 #   foo_blink
 #       C++ bindings using Blink standard types.
 #
 #   foo_java
 #       Java bindings.
 #
+#   foo_js
+#       JavaScript bindings; used as compile-time dependency.
+#
+#   foo_js_data_deps
+#       JavaScript bindings; used as run-time dependency.
+#
 # Parameters:
 #
 #   sources (optional if one of the deps sets listed below is present)
 #       List of source .mojom files to compile.
 #
 #   deps (optional)
 #       Note: this can contain only other mojom targets.
 #
 #       DEPRECATED: This is synonymous with public_deps because all mojom
 #       dependencies must be public by design. Please use public_deps.
@@ skipping 103 matching lines @@
     assert(defined(invoker.overridden_deps))
     assert(defined(invoker.component_deps))
   }
 
   if (defined(invoker.overridden_deps_blink) ||
       defined(invoker.component_deps_blink)) {
     assert(defined(invoker.overridden_deps_blink))
     assert(defined(invoker.component_deps_blink))
   }
 
+  if (defined(invoker.use_new_js_bindings)) {
+    assert(invoker.use_new_js_bindings || !invoker.use_new_js_bindings,
+           "Surpress unused variable error when JS bindings are not needed.")
+  }
+
   all_deps = []
   if (defined(invoker.deps)) {
     all_deps += invoker.deps
   }
   if (defined(invoker.public_deps)) {
     all_deps += invoker.public_deps
   }
 
   if (defined(invoker.component_macro_prefix)) {
     assert(defined(invoker.component_output_prefix))
@@ skipping 203 matching lines @@
       variant_suffix = "_${variant}"
       cpp_only = true
     }
     type_mappings_target_name = "${target_name}${variant_suffix}__type_mappings"
     type_mappings_path =
         "$target_gen_dir/${target_name}${variant_suffix}__type_mappings"
     active_typemaps = []
     enabled_sources = []
     if (defined(invoker.sources)) {
       generator_cpp_outputs = []
-      generator_js_outputs = []
       generator_java_outputs = []
       variant_dash_suffix = ""
       if (defined(variant)) {
         variant_dash_suffix = "-${variant}"
       }
       generator_cpp_outputs += [
         "{{source_gen_dir}}/{{source_name_part}}.mojom${variant_dash_suffix}.cc",
         "{{source_gen_dir}}/{{source_name_part}}.mojom${variant_dash_suffix}.h",
       ]
       enabled_sources = []
@@ skipping 63 matching lines @@
             "${invoker.component_macro_prefix}${bindings_configuration.component_macro_suffix}_IMPL",
             "--output_file",
             rebase_path(generated_export_header, root_build_dir),
             "--relative_path",
             rebase_path(generated_export_header, root_gen_dir),
           ]
         }
       }
 
       if (!cpp_only) {
-        generator_js_outputs =
-            [ "{{source_gen_dir}}/{{source_name_part}}.mojom.js" ]
         generator_java_outputs =
             [ "{{source_gen_dir}}/{{source_name_part}}.mojom.srcjar" ]
       }
       generator_target_name = "${target_name}${variant_suffix}__generator"
       action_foreach(generator_target_name) {
         script = mojom_generator_script
         inputs = mojom_generator_sources
         sources = invoker.sources
         deps = [
           ":$type_mappings_target_name",
           "//mojo/public/tools/bindings:precompile_templates",
         ]
-        outputs = generator_cpp_outputs + generator_java_outputs +
-                  generator_js_outputs
+        outputs = generator_cpp_outputs + generator_java_outputs
         args = common_generator_args
 
         if (cpp_only) {
           args += [
             "-g",
             "c++",
           ]
         } else {
           args += [
             "-g",
-            "c++,javascript,java",
+            "c++,java",
           ]
         }
 
         if (defined(bindings_configuration.variant)) {
           args += [
             "--variant",
             bindings_configuration.variant,
           ]
         }
         depfile =
@@ skipping 37 matching lines @@
               invoker.export_class_attribute,
               "--export_header",
               invoker.export_header,
             ]
           }
         }
 
         if (!defined(invoker.use_once_callback) || invoker.use_once_callback) {
           args += [ "--use_once_callback" ]
         }
-
-        if (!defined(invoker.use_new_js_bindings) ||
-            invoker.use_new_js_bindings) {
-          args += [ "--use_new_js_bindings" ]
-        }
       }
     }
 
     action(type_mappings_target_name) {
       inputs = _bindings_configuration_files
       outputs = [
         type_mappings_path,
       ]
       script = "$mojom_generator_root/generate_type_mappings.py"
       deps = []
@@ skipping 62 matching lines @@
       if (defined(bindings_configuration.for_blink) &&
           bindings_configuration.for_blink &&
           defined(invoker.visibility_blink)) {
         visibility = invoker.visibility_blink
       } else if (defined(invoker.visibility)) {
         visibility = invoker.visibility
       }
       if (defined(invoker.testonly)) {
         testonly = invoker.testonly
       }
-      if (defined(invoker.sources) && !defined(bindings_configuration.variant)) {
-        data = process_file_template(enabled_sources, generator_js_outputs)
-      }
       defines = []
       if (defined(invoker.testonly)) {
         testonly = invoker.testonly
       }
       if (defined(invoker.export_define)) {
         defines += [ invoker.export_define ]
       }
       if (defined(invoker.export_define_blink)) {
         defines += [ invoker.export_define_blink ]
       }
@@ skipping 122 matching lines @@
           # dependency name.
           full_name = get_label_info(d, "label_no_toolchain")
           deps += [ "${full_name}_java" ]
         }
 
         srcjar_deps = [ ":$java_srcjar_target_name" ]
         run_findbugs_override = false
       }
     }
   }
+
+  if (!defined(invoker.cpp_only) || !invoker.cpp_only) {
+    if (defined(invoker.sources)) {
+      generator_js_target_name = "${target_name}_js__generator"
+      generator_js_outputs =
+          [ "{{source_gen_dir}}/{{source_name_part}}.mojom.js" ]
+      action_foreach(generator_js_target_name) {
+        script = mojom_generator_script
+        inputs = mojom_generator_sources
+        sources = []
+        if (defined(invoker.sources)) {
+          sources += invoker.sources
+        }
+        deps = [
+          "//mojo/public/tools/bindings:precompile_templates",
+        ]
+        outputs = generator_js_outputs
+        args = common_generator_args
+        args += [
+          "-g",
+          "javascript",
+        ]
+
+        if (!defined(invoker.use_new_js_bindings) ||
+            invoker.use_new_js_bindings) {
+          args += [ "--use_new_js_bindings" ]
+        }
+      }
+    }
+
+    js_target_name = target_name + "_js"
+    group(js_target_name) {
+      public_deps = []
+      if (defined(invoker.sources)) {
+        public_deps += [ ":$generator_js_target_name" ]
+      }
+
+      foreach(d, all_deps) {
+        full_name = get_label_info(d, "label_no_toolchain")
+        public_deps += [ "${full_name}_js" ]
+      }
+    }
+
+    js_data_deps_target_name = target_name + "_js_data_deps"
+    group(js_data_deps_target_name) {
+      deps = []
+      if (defined(invoker.sources)) {
+        data = process_file_template(invoker.sources, generator_js_outputs)
+        deps += [ ":$generator_js_target_name" ]
+      }
+
+      data_deps = []
+      foreach(d, all_deps) {
+        full_name = get_label_info(d, "label_no_toolchain")
+        data_deps += [ "${full_name}_js_data_deps" ]
+      }
+    }
+  }
 }
 
 # A helper for the mojom() template above when component libraries are desired
 # for generated C++ bindings units. Supports all the same arguments as mojom()
 # except for the optional |component_output_prefix| and |component_macro_prefix|
 # arguments. These are instead shortened to |output_prefix| and |macro_prefix|
 # and are *required*.
 template("mojom_component") {
   assert(defined(invoker.output_prefix) && defined(invoker.macro_prefix))
 
   mojom(target_name) {
     forward_variables_from(invoker,
                            "*",
                            [
                              "output_prefix",
                              "macro_prefix",
                            ])
     component_output_prefix = invoker.output_prefix
     component_macro_prefix = invoker.macro_prefix
   }
 }