Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / build / json_schema_api.gni
blob24867d11eaedce0bba7a7f2fb6aa0c437ba36787
1 # Copyright 2014 The Chromium Authors. All rights reserved.
2 # Use of this source code is governed by a BSD-style license that can be
3 # found in the LICENSE file.
5 # Defines a static library corresponding to the output of schema compiler tools
6 # over a set of extensions API schemas (IDL or JSON format.) The library target
7 # has implicit hard dependencies on all schema files listed by the invoker and
8 # is itself a hard dependency.
10 # Invocations of this template may use the following variables:
12 # sources [required] A list of schema files to be compiled.
14 # root_namespace [required]
15 #     A Python string substituion pattern used to generate the C++
16 #     namespace for each API. Use %(namespace)s to replace with the API
17 #     namespace, like "toplevel::%(namespace)s_api".
19 # schema_include_rules [optional]
20 #     A list of paths to include when searching for referenced objects,
21 #     with the namespace separated by a :.
22 #     Example:
23 #       [ '/foo/bar:Foo::Bar::%(namespace)s' ]
25 # schemas [optional, default = false]
26 #   Boolean indicating if the schema files should be generated.
28 # bundle [optional, default = false]
29 #   Boolean indicating if the schema bundle files should be generated.
31 # bundle_registration [optional, default = false]
32 #   Boolean indicating if the API registration bundle files should be generated.
34 # bundle_name [required if bundle or bundle_registrations]:
35 #     A string to prepend to generated bundle class names, so that multiple
36 #     bundle rules can be used without conflicting.  Only used with one of
37 #     the cpp-bundle generators.
39 # impl_dir [required if bundle_registration = true, otherwise unused]
40 #   The path containing C++ implementations of API functions. This path is
41 #   used as the root path when looking for {schema}/{schema}_api.h headers
42 #   when generating API registration bundles. Such headers, if found, are
43 #   automatically included by the generated code.
45 # uncompiled_sources [optional, only used when bundle = true or
46 #     bundle_registration = true]
47 #   A list of schema files which should not be compiled, but which should still
48 #   be processed for API bundle generation.
50 # configs [optional]
51 #   Extra configs to apply to the compile step.
53 # deps [optional]
54 #   If any deps are specified they will be inherited by the static library
55 #   target.
57 # generate_static_library [optional, defaults to false]
58 #   Produces a static library instead of a source_set.
60 # The generated library target also inherits the visibility and output_name
61 # of its invoker.
63 template("json_schema_api") {
64   assert(defined(invoker.sources),
65          "\"sources\" must be defined for the $target_name template.")
66   assert(defined(invoker.root_namespace),
67          "\"root_namespace\" must be defined for the $target_name template.")
69   schemas = defined(invoker.schemas) && invoker.schemas
70   bundle = defined(invoker.bundle) && invoker.bundle
71   bundle_registration =
72       defined(invoker.bundle_registration) && invoker.bundle_registration
74   schema_include_rules = ""
75   if (defined(invoker.schema_include_rules)) {
76     schema_include_rules = invoker.schema_include_rules
77   }
79   # Keep a copy of the target_name here since it will be trampled
80   # in nested targets.
81   target_visibility = [ ":$target_name" ]
83   generated_config_name = target_name + "_generated_config"
84   config(generated_config_name) {
85     include_dirs = [ root_gen_dir ]
86     visibility = target_visibility
87   }
89   root_namespace = invoker.root_namespace
91   compiler_root = "//tools/json_schema_compiler"
92   compiler_script = "$compiler_root/compiler.py"
93   compiler_sources = [
94     "$compiler_root/cc_generator.py",
95     "$compiler_root/code.py",
96     "$compiler_root/compiler.py",
97     "$compiler_root/cpp_bundle_generator.py",
98     "$compiler_root/cpp_generator.py",
99     "$compiler_root/cpp_type_generator.py",
100     "$compiler_root/cpp_util.py",
101     "$compiler_root/h_generator.py",
102     "$compiler_root/idl_schema.py",
103     "$compiler_root/model.py",
104     "$compiler_root/util_cc_helper.py",
105   ]
107   if (schemas) {
108     schema_generator_name = target_name + "_schema_generator"
109     action_foreach(schema_generator_name) {
110       script = compiler_script
111       sources = invoker.sources
112       inputs = compiler_sources
113       outputs = [
114         "$target_gen_dir/{{source_name_part}}.cc",
115         "$target_gen_dir/{{source_name_part}}.h",
116       ]
117       args = [
118         "{{source}}",
119         "--root=" + rebase_path("//", root_build_dir),
120         "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
121         "--namespace=$root_namespace",
122         "--generator=cpp",
123         "--include-rules=$schema_include_rules",
124       ]
126       if (defined(invoker.visibility)) {
127         # If visibility is restricted, add our own target to it.
128         visibility = invoker.visibility + target_visibility
129       }
130     }
131   }
133   if (bundle) {
134     assert(defined(invoker.bundle_name),
135            "\"bundle_name\" must be defined for bundles")
137     uncompiled_sources = []
138     if (defined(invoker.uncompiled_sources)) {
139       uncompiled_sources = invoker.uncompiled_sources
140     }
142     bundle_generator_schema_name = target_name + "_bundle_generator_schema"
143     action(bundle_generator_schema_name) {
144       script = compiler_script
145       inputs = compiler_sources + invoker.sources + uncompiled_sources
146       outputs = [
147         "$target_gen_dir/generated_schemas.cc",
148         "$target_gen_dir/generated_schemas.h",
149       ]
150       args = [
151                "--root=" + rebase_path("//", root_build_dir),
152                "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
153                "--namespace=$root_namespace",
154                "--bundle-name=" + invoker.bundle_name,
155                "--generator=cpp-bundle-schema",
156                "--include-rules=$schema_include_rules",
157              ] + rebase_path(invoker.sources, root_build_dir) +
158              rebase_path(uncompiled_sources, root_build_dir)
159     }
160   }
162   if (bundle_registration) {
163     assert(defined(invoker.bundle_name),
164            "\"bundle_name\" must be defined for bundle registrations")
166     uncompiled_sources = []
167     if (defined(invoker.uncompiled_sources)) {
168       uncompiled_sources = invoker.uncompiled_sources
169     }
171     assert(defined(invoker.impl_dir),
172            "\"impl_dir\" must be defined for the $target_name template.")
174     # Child directory inside the generated file tree.
175     gen_child_dir = rebase_path(invoker.impl_dir, "//")
177     bundle_generator_registration_name =
178         target_name + "_bundle_generator_registration"
179     action(bundle_generator_registration_name) {
180       script = compiler_script
181       inputs = compiler_sources + invoker.sources + uncompiled_sources
182       outputs = [
183         "$root_gen_dir/$gen_child_dir/generated_api_registration.cc",
184         "$root_gen_dir/$gen_child_dir/generated_api_registration.h",
185       ]
186       args = [
187                "--root=" + rebase_path("//", root_build_dir),
188                "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
189                "--namespace=$root_namespace",
190                "--bundle-name=" + invoker.bundle_name,
191                "--generator=cpp-bundle-registration",
192                "--impl-dir=$gen_child_dir",
193                "--include-rules=$schema_include_rules",
194              ] + rebase_path(invoker.sources, root_build_dir) +
195              rebase_path(uncompiled_sources, root_build_dir)
196     }
197   }
199   # Compute the contents of the library/source set.
200   lib_sources = invoker.sources
201   lib_deps = []
202   lib_public_deps = []
203   lib_extra_configs = []
204   if (defined(invoker.configs)) {
205     lib_extra_configs += invoker.configs
206   }
208   if (schemas) {
209     lib_sources += get_target_outputs(":$schema_generator_name")
210     lib_public_deps += [ ":$schema_generator_name" ]
211     lib_deps += [ "//tools/json_schema_compiler:generated_api_util" ]
212     lib_extra_configs += [ "//build/config/compiler:no_size_t_to_int_warning" ]
213   }
215   if (bundle) {
216     lib_sources += get_target_outputs(":$bundle_generator_schema_name")
217     lib_deps += [ ":$bundle_generator_schema_name" ]
218   }
220   if (bundle_registration) {
221     lib_sources += get_target_outputs(":$bundle_generator_registration_name")
222     lib_deps += [ ":$bundle_generator_registration_name" ]
223   }
225   if (defined(invoker.deps)) {
226     lib_deps += invoker.deps
227   }
229   # Generate either a static library or a source set.
230   if (defined(invoker.generate_static_library) &&
231       invoker.generate_static_library) {
232     static_library(target_name) {
233       sources = lib_sources
234       deps = lib_deps
235       public_deps = lib_public_deps
236       configs += lib_extra_configs
237       public_configs = [ ":$generated_config_name" ]
239       if (defined(invoker.visibility)) {
240         visibility = invoker.visibility
241       }
242       if (defined(invoker.output_name)) {
243         output_name = invoker.output_name
244       }
245     }
246   } else {
247     source_set(target_name) {
248       sources = lib_sources
249       deps = lib_deps
250       public_deps = lib_public_deps
251       configs += lib_extra_configs
252       public_configs = [ ":$generated_config_name" ]
254       if (defined(invoker.visibility)) {
255         visibility = invoker.visibility
256       }
257       if (defined(invoker.output_name)) {
258         output_name = invoker.output_name
259       }
260     }
261   }