OLD | NEW |
---|---|
1 # Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 # Use of this source code is governed by a BSD-style license that can be |
3 # found in the LICENSE file. | 3 # found in the LICENSE file. |
4 | 4 |
5 import("//build/config/chrome_build.gni") | 5 import("//build/config/chrome_build.gni") |
6 import("//build/config/features.gni") | 6 import("//build/config/features.gni") |
7 import("//build/toolchain/toolchain.gni") | 7 import("//build/toolchain/toolchain.gni") |
8 import("//components/policy/resources/policy_templates.gni") | 8 import("//components/policy/resources/policy_templates.gni") |
9 import("//third_party/protobuf/proto_library.gni") | 9 import("//third_party/protobuf/proto_library.gni") |
10 import("//tools/grit/grit_rule.gni") | 10 import("//tools/grit/grit_rule.gni") |
11 | 11 |
12 assert(!is_ios, "Policy should not be referenced on iOS") | |
13 | |
12 # To test policy generation for platforms different than your OS, override and | 14 # To test policy generation for platforms different than your OS, override and |
13 # enable these flags (but don't check that in!). | 15 # enable these flags (but don't check that in!). |
14 gen_policy_templates_common = true | 16 gen_policy_templates_common = true |
15 gen_policy_templates_win = is_win | 17 gen_policy_templates_win = is_win |
16 gen_policy_templates_linux = is_linux | 18 gen_policy_templates_linux = is_linux |
17 gen_policy_templates_android = is_android | 19 gen_policy_templates_android = is_android |
18 gen_policy_templates_mac = is_mac | 20 gen_policy_templates_mac = is_mac |
19 | 21 |
20 if (is_mac) { | 22 if (is_mac) { |
21 import("//build/util/branding.gni") | 23 import("//build/util/branding.gni") |
(...skipping 15 matching lines...) Expand all Loading... | |
37 "//components/policy/core/common:internal", | 39 "//components/policy/core/common:internal", |
38 ] | 40 ] |
39 } | 41 } |
40 } | 42 } |
41 | 43 |
42 # Used by targets that compile into the implementation. | 44 # Used by targets that compile into the implementation. |
43 config("component_implementation") { | 45 config("component_implementation") { |
44 defines = [ "POLICY_COMPONENT_IMPLEMENTATION" ] | 46 defines = [ "POLICY_COMPONENT_IMPLEMENTATION" ] |
45 } | 47 } |
46 | 48 |
47 if (enable_configuration_policy) { | 49 # This protobuf is equivalent to chrome_settings.proto but shares messages |
48 # This protobuf is equivalent to chrome_settings.proto but shares messages | 50 # for policies of the same type, so that less classes have to be generated |
49 # for policies of the same type, so that less classes have to be generated | 51 # and compiled. |
50 # and compiled. | 52 cloud_policy_proto_path = "$target_gen_dir/proto/cloud_policy.proto" |
51 cloud_policy_proto_path = "$target_gen_dir/proto/cloud_policy.proto" | 53 |
52 | 54 # This is the "full" protobuf, which defines one protobuf message per |
53 # This is the "full" protobuf, which defines one protobuf message per | 55 # policy. It is also the format currently used by the server. |
54 # policy. It is also the format currently used by the server. | 56 chrome_settings_proto_path = "$target_gen_dir/proto/chrome_settings.proto" |
55 chrome_settings_proto_path = "$target_gen_dir/proto/chrome_settings.proto" | 57 |
56 | 58 constants_header_path = "$target_gen_dir/policy_constants.h" |
57 constants_header_path = "$target_gen_dir/policy_constants.h" | 59 constants_source_path = "$target_gen_dir/policy_constants.cc" |
58 constants_source_path = "$target_gen_dir/policy_constants.cc" | 60 protobuf_decoder_path = "$target_gen_dir/cloud_policy_generated.cc" |
59 protobuf_decoder_path = "$target_gen_dir/cloud_policy_generated.cc" | 61 app_restrictions_path = "$target_gen_dir/app_restrictions.xml" |
60 app_restrictions_path = "$target_gen_dir/app_restrictions.xml" | 62 risk_tag_header_path = "$target_gen_dir/risk_tag.h" |
61 risk_tag_header_path = "$target_gen_dir/risk_tag.h" | 63 |
62 | 64 action("cloud_policy_code_generate") { |
63 action("cloud_policy_code_generate") { | 65 script = "tools/generate_policy_source.py" |
64 script = "tools/generate_policy_source.py" | 66 chrome_version_abspath = "//chrome/VERSION" |
65 chrome_version_abspath = "//chrome/VERSION" | 67 chrome_version_path = rebase_path(chrome_version_abspath, root_build_dir) |
66 chrome_version_path = rebase_path(chrome_version_abspath, root_build_dir) | 68 |
67 | 69 if (is_chromeos) { |
68 if (is_chromeos) { | 70 chromeos_flag = "1" |
69 chromeos_flag = "1" | 71 } else { |
72 chromeos_flag = "0" | |
73 } | |
74 | |
75 inputs = [ | |
76 chrome_version_abspath, | |
77 "resources/policy_templates.json", | |
78 ] | |
79 outputs = [ | |
80 constants_header_path, | |
81 constants_source_path, | |
82 protobuf_decoder_path, | |
83 chrome_settings_proto_path, | |
84 cloud_policy_proto_path, | |
85 app_restrictions_path, | |
86 risk_tag_header_path, | |
87 ] | |
88 | |
89 if (target_os != "android") { | |
90 outputs -= [ app_restrictions_path ] | |
91 } | |
92 | |
93 args = [ | |
94 "--policy-constants-header=" + | |
95 rebase_path(constants_header_path, root_build_dir), | |
96 "--policy-constants-source=" + | |
97 rebase_path(constants_source_path, root_build_dir), | |
98 "--chrome-settings-protobuf=" + | |
99 rebase_path(chrome_settings_proto_path, root_build_dir), | |
100 "--cloud-policy-protobuf=" + | |
101 rebase_path(cloud_policy_proto_path, root_build_dir), | |
102 "--cloud-policy-decoder=" + | |
103 rebase_path(protobuf_decoder_path, root_build_dir), | |
104 "--app-restrictions-definition=" + | |
105 rebase_path(app_restrictions_path, root_build_dir), | |
106 "--risk-tag-header=" + rebase_path(risk_tag_header_path, root_build_dir), | |
107 chrome_version_path, | |
108 target_os, | |
109 chromeos_flag, | |
110 rebase_path("resources/policy_templates.json", root_build_dir), | |
111 ] | |
112 } | |
113 | |
114 policy_templates_grd_file = "resources/policy_templates.grd" | |
115 | |
116 grit("grit_policy_templates") { | |
117 source = policy_templates_grd_file | |
118 use_qualified_include = true | |
119 output_dir = "$root_gen_dir/chrome" | |
120 outputs = [] | |
121 defines = [] | |
122 | |
123 if (gen_policy_templates_common) { | |
124 outputs += policy_templates_doc_outputs | |
125 defines += [ "gen_policy_templates_common" ] | |
126 } | |
127 if (gen_policy_templates_android) { | |
128 outputs += policy_templates_android_outputs | |
129 defines += [ "gen_policy_templates_android" ] | |
130 } | |
131 if (gen_policy_templates_linux) { | |
132 outputs += policy_templates_linux_outputs | |
133 defines += [ "gen_policy_templates_linux" ] | |
134 } | |
135 if (gen_policy_templates_mac) { | |
136 outputs += policy_templates_mac_outputs | |
137 defines += [ | |
138 "mac_bundle_id=$chrome_mac_bundle_id", | |
139 "gen_policy_templates_mac", | |
140 ] | |
141 } | |
142 if (gen_policy_templates_win) { | |
143 outputs += policy_templates_windows_outputs | |
144 defines += [ "gen_policy_templates_win" ] | |
145 } | |
146 } | |
147 | |
148 if (gen_policy_templates_win && is_chrome_branded) { | |
149 # Creates google.admx and google.adml files that define a common 'Google' | |
150 # category used for Chrome, Chrome OS and possibly external tools, see | |
151 # crbug.com/665400. | |
152 action("create_google_admx") { | |
153 script = "tools/create_google_admx.py" | |
154 inputs = [ | |
155 policy_templates_grd_file, | |
156 grit_info_script, | |
157 ] + policy_templates_windows_outputs | |
158 outputs = policy_templates_windows_google_outputs | |
159 deps = [ | |
160 ":grit_policy_templates", | |
161 ] | |
162 | |
163 # Don't pass in outputs directly, it would exceed a limit on Windows! | |
164 args = [ | |
165 "--basedir", | |
166 rebase_path(policy_templates_base_dir, root_build_dir), | |
167 "--grd_strip_path_prefix", | |
168 "app/policy/", | |
169 "--grd_input", | |
170 rebase_path(policy_templates_grd_file, root_build_dir), | |
171 "--grit_info", | |
172 rebase_path(grit_info_script, root_build_dir), | |
173 "-D", | |
174 "gen_policy_templates_win", | |
175 ] + grit_defines | |
176 } | |
177 } | |
178 | |
179 group("policy_templates") { | |
180 public_deps = [ | |
181 ":grit_policy_templates", | |
182 ] | |
183 if (gen_policy_templates_win && is_chrome_branded) { | |
184 public_deps += [ ":create_google_admx" ] | |
185 } | |
186 } | |
187 | |
188 # Run the proto compiler over the generated file and make it a component. | |
189 component("cloud_policy_proto_generated_compile") { | |
190 public_deps = [ | |
191 ":cloud_policy_proto_generated_compile_proto", | |
192 ] | |
193 } | |
194 proto_library("cloud_policy_proto_generated_compile_proto") { | |
195 visibility = [ ":cloud_policy_proto_generated_compile" ] | |
196 sources = [ | |
197 cloud_policy_proto_path, | |
198 ] | |
199 | |
200 proto_out_dir = "components/policy/proto" | |
201 cc_generator_options = "dllexport_decl=POLICY_PROTO_EXPORT:" | |
202 cc_include = "components/policy/proto/policy_proto_export.h" | |
203 component_build_force_source_set = true | |
204 defines = [ "POLICY_PROTO_COMPILATION" ] | |
205 | |
206 deps = [ | |
207 ":cloud_policy_code_generate", | |
208 ] | |
209 } | |
210 | |
211 # This target builds the "full" protobuf, used for tests only. | |
212 proto_library("chrome_settings_proto") { | |
213 testonly = true | |
214 sources = [ | |
215 chrome_settings_proto_path, | |
216 ] | |
217 proto_out_dir = "components/policy/proto" | |
218 | |
219 deps = [ | |
220 ":cloud_policy_code_generate", | |
221 ":cloud_policy_proto_generated_compile", | |
222 ] | |
223 } | |
224 | |
225 static_library("generated") { | |
226 sources = [ | |
227 constants_header_path, | |
228 constants_source_path, | |
229 protobuf_decoder_path, | |
230 risk_tag_header_path, | |
231 ] | |
232 | |
233 defines = [ "POLICY_COMPONENT_IMPLEMENTATION" ] | |
234 public_deps = [ | |
235 ":cloud_policy_code_generate", | |
236 ":cloud_policy_proto_generated_compile", | |
237 "//base", | |
238 "//third_party/protobuf:protobuf_lite", | |
239 ] | |
240 } | |
241 | |
242 if (gen_policy_templates_android && is_android) { | |
243 import("//build/config/android/rules.gni") | |
244 | |
245 _generated_resources_dir = "$root_gen_dir/chrome/app/policy/android" | |
246 | |
247 copy("app_restrictions_resources_copy") { | |
248 sources = [ | |
249 app_restrictions_path, | |
250 ] | |
251 outputs = [ | |
252 "$_generated_resources_dir/xml-v21/app_restrictions.xml", | |
253 ] | |
254 deps = [ | |
255 ":cloud_policy_code_generate", | |
256 ":policy_templates", | |
257 ] | |
258 } | |
259 | |
260 android_resources("app_restrictions_resources") { | |
261 resource_dirs = [] | |
262 generated_resource_dirs = [ | |
263 "$policy_templates_base_dir/android", | |
264 _generated_resources_dir, | |
265 ] | |
266 generated_resource_files = | |
267 policy_templates_android_outputs + | |
268 [ "$_generated_resources_dir/xml-v21/app_restrictions.xml" ] | |
269 deps = [ | |
270 ":app_restrictions_resources_copy", | |
271 ":grit_policy_templates", | |
272 ] | |
273 } | |
274 } else if (gen_policy_templates_mac && is_mac) { | |
275 action("convert_mcx_plist") { | |
276 script = "//build/config/mac/xcrun.py" | |
277 sources = [ | |
278 "$policy_templates_base_dir/mac/app-Manifest.plist", | |
279 ] | |
280 inputs = [ | |
281 script, | |
282 ] | |
283 outputs = [ | |
284 "$target_gen_dir/$chrome_mac_bundle_id.manifest", | |
285 ] | |
286 | |
287 if (use_system_xcode) { | |
288 args = [] | |
70 } else { | 289 } else { |
71 chromeos_flag = "0" | 290 args = [ |
72 } | 291 "--developer_dir", |
73 | 292 hermetic_xcode_path, |
74 inputs = [ | |
75 chrome_version_abspath, | |
76 "resources/policy_templates.json", | |
77 ] | |
78 outputs = [ | |
79 constants_header_path, | |
80 constants_source_path, | |
81 protobuf_decoder_path, | |
82 chrome_settings_proto_path, | |
83 cloud_policy_proto_path, | |
84 app_restrictions_path, | |
85 risk_tag_header_path, | |
86 ] | |
87 | |
88 if (target_os != "android") { | |
89 outputs -= [ app_restrictions_path ] | |
90 } | |
91 | |
92 args = [ | |
93 "--policy-constants-header=" + | |
94 rebase_path(constants_header_path, root_build_dir), | |
95 "--policy-constants-source=" + | |
96 rebase_path(constants_source_path, root_build_dir), | |
97 "--chrome-settings-protobuf=" + | |
98 rebase_path(chrome_settings_proto_path, root_build_dir), | |
99 "--cloud-policy-protobuf=" + | |
100 rebase_path(cloud_policy_proto_path, root_build_dir), | |
101 "--cloud-policy-decoder=" + | |
102 rebase_path(protobuf_decoder_path, root_build_dir), | |
103 "--app-restrictions-definition=" + | |
104 rebase_path(app_restrictions_path, root_build_dir), | |
105 "--risk-tag-header=" + rebase_path(risk_tag_header_path, root_build_dir), | |
106 chrome_version_path, | |
107 target_os, | |
108 chromeos_flag, | |
109 rebase_path("resources/policy_templates.json", root_build_dir), | |
110 ] | |
111 } | |
112 | |
113 policy_templates_grd_file = "resources/policy_templates.grd" | |
114 | |
115 grit("grit_policy_templates") { | |
116 source = policy_templates_grd_file | |
117 use_qualified_include = true | |
118 output_dir = "$root_gen_dir/chrome" | |
119 outputs = [] | |
120 defines = [] | |
121 | |
122 if (gen_policy_templates_common) { | |
123 outputs += policy_templates_doc_outputs | |
124 defines += [ "gen_policy_templates_common" ] | |
125 } | |
126 if (gen_policy_templates_android) { | |
127 outputs += policy_templates_android_outputs | |
128 defines += [ "gen_policy_templates_android" ] | |
129 } | |
130 if (gen_policy_templates_linux) { | |
131 outputs += policy_templates_linux_outputs | |
132 defines += [ "gen_policy_templates_linux" ] | |
133 } | |
134 if (gen_policy_templates_mac) { | |
135 outputs += policy_templates_mac_outputs | |
136 defines += [ | |
137 "mac_bundle_id=$chrome_mac_bundle_id", | |
138 "gen_policy_templates_mac", | |
139 ] | 293 ] |
140 } | 294 } |
141 if (gen_policy_templates_win) { | 295 args += [ |
142 outputs += policy_templates_windows_outputs | 296 "plutil", |
143 defines += [ "gen_policy_templates_win" ] | 297 "-convert", |
298 "xml1", | |
299 ] + rebase_path(sources, root_out_dir) + [ "-o" ] + | |
300 rebase_path(outputs, root_out_dir) | |
301 | |
302 deps = [ | |
303 ":policy_templates", | |
304 ] | |
305 } | |
306 | |
307 bundle_data("manifest_bundle_data") { | |
308 sources = get_target_outputs(":convert_mcx_plist") | |
309 outputs = [ | |
310 "{{bundle_resources_dir}}/{{source_file_part}}", | |
311 ] | |
312 public_deps = [ | |
313 ":convert_mcx_plist", | |
314 ] | |
315 } | |
316 | |
317 # The reason we are not enumerating all the locales is that | |
318 # the translations would eat up 3.5MB disk space in the | |
319 # application bundle. | |
320 bundle_data("manifest_strings_bundle_data") { | |
321 sources = [ | |
322 "$policy_templates_base_dir/mac/strings/en.lproj/Localizable.strings", | |
323 ] | |
324 outputs = [ | |
325 "{{bundle_resources_dir}}/en.lproj/{{source_file_part}}", | |
326 ] | |
327 public_deps = [ | |
328 ":policy_templates", | |
329 ] | |
330 } | |
331 | |
332 create_bundle("chrome_manifest_bundle") { | |
333 bundle_root_dir = "$root_out_dir/$chrome_mac_bundle_id.manifest/Contents" | |
334 bundle_resources_dir = "$bundle_root_dir/Resources" | |
335 | |
336 deps = [ | |
337 ":manifest_bundle_data", | |
338 ":manifest_strings_bundle_data", | |
339 ] | |
340 } | |
Andrew T Wilson (Slow)
2016/12/09 22:58:08
Not looking that closely at this file - I'm presum
brettw
2016/12/09 23:16:20
Yup, thanks.
| |
341 } | |
342 | |
343 if (gen_policy_templates_common && gen_policy_templates_win) { | |
344 version_file = "VERSION" | |
345 version_path = "$policy_templates_base_dir/$version_file" | |
346 | |
347 copy("add_version") { | |
348 sources = [ | |
349 "//chrome/VERSION", | |
350 ] | |
351 outputs = [ | |
352 version_path, | |
353 ] | |
354 } | |
355 | |
356 action("pack_policy_templates") { | |
357 output_zip_file = "$root_out_dir/policy_templates.zip" | |
358 script = "tools/make_policy_zip.py" | |
359 inputs = [ | |
360 version_path, | |
361 policy_templates_grd_file, | |
362 grit_info_script, | |
363 ] + policy_templates_windows_outputs + policy_templates_doc_outputs | |
364 outputs = [ | |
365 output_zip_file, | |
366 ] | |
367 args = [ | |
368 "--output", | |
369 rebase_path(output_zip_file, root_build_dir), | |
370 "--basedir", | |
371 rebase_path(policy_templates_base_dir, root_build_dir), | |
372 "--grd_input", | |
373 rebase_path(policy_templates_grd_file, root_build_dir), | |
374 "--grd_strip_path_prefix", | |
375 "app/policy", | |
376 "--extra_input", | |
377 version_file, | |
378 "--grit_info", | |
379 rebase_path(grit_info_script, root_build_dir), | |
380 "-D", | |
381 "gen_policy_templates_common", | |
382 "-D", | |
383 "gen_policy_templates_win", | |
384 ] + grit_defines | |
385 if (is_chrome_branded) { | |
386 args += [ "--include_google_admx" ] | |
144 } | 387 } |
145 } | 388 deps = [ |
146 | 389 ":add_version", |
147 if (gen_policy_templates_win && is_chrome_branded) { | 390 ":policy_templates", |
148 # Creates google.admx and google.adml files that define a common 'Google' | 391 ] |
149 # category used for Chrome, Chrome OS and possibly external tools, see | 392 } |
150 # crbug.com/665400. | 393 } |
151 action("create_google_admx") { | |
152 script = "tools/create_google_admx.py" | |
153 inputs = [ | |
154 policy_templates_grd_file, | |
155 grit_info_script, | |
156 ] + policy_templates_windows_outputs | |
157 outputs = policy_templates_windows_google_outputs | |
158 deps = [ | |
159 ":grit_policy_templates", | |
160 ] | |
161 | |
162 # Don't pass in outputs directly, it would exceed a limit on Windows! | |
163 args = [ | |
164 "--basedir", | |
165 rebase_path(policy_templates_base_dir, root_build_dir), | |
166 "--grd_strip_path_prefix", | |
167 "app/policy/", | |
168 "--grd_input", | |
169 rebase_path(policy_templates_grd_file, root_build_dir), | |
170 "--grit_info", | |
171 rebase_path(grit_info_script, root_build_dir), | |
172 "-D", | |
173 "gen_policy_templates_win", | |
174 ] + grit_defines | |
175 } | |
176 } | |
177 | |
178 group("policy_templates") { | |
179 public_deps = [ | |
180 ":grit_policy_templates", | |
181 ] | |
182 if (gen_policy_templates_win && is_chrome_branded) { | |
183 public_deps += [ ":create_google_admx" ] | |
184 } | |
185 } | |
186 | |
187 # Run the proto compiler over the generated file and make it a component. | |
188 component("cloud_policy_proto_generated_compile") { | |
189 public_deps = [ | |
190 ":cloud_policy_proto_generated_compile_proto", | |
191 ] | |
192 } | |
193 proto_library("cloud_policy_proto_generated_compile_proto") { | |
194 visibility = [ ":cloud_policy_proto_generated_compile" ] | |
195 sources = [ | |
196 cloud_policy_proto_path, | |
197 ] | |
198 | |
199 proto_out_dir = "components/policy/proto" | |
200 cc_generator_options = "dllexport_decl=POLICY_PROTO_EXPORT:" | |
201 cc_include = "components/policy/proto/policy_proto_export.h" | |
202 component_build_force_source_set = true | |
203 defines = [ "POLICY_PROTO_COMPILATION" ] | |
204 | |
205 deps = [ | |
206 ":cloud_policy_code_generate", | |
207 ] | |
208 } | |
209 | |
210 # This target builds the "full" protobuf, used for tests only. | |
211 proto_library("chrome_settings_proto") { | |
212 testonly = true | |
213 sources = [ | |
214 chrome_settings_proto_path, | |
215 ] | |
216 proto_out_dir = "components/policy/proto" | |
217 | |
218 deps = [ | |
219 ":cloud_policy_code_generate", | |
220 ":cloud_policy_proto_generated_compile", | |
221 ] | |
222 } | |
223 | |
224 static_library("generated") { | |
225 sources = [ | |
226 constants_header_path, | |
227 constants_source_path, | |
228 protobuf_decoder_path, | |
229 risk_tag_header_path, | |
230 ] | |
231 | |
232 defines = [ "POLICY_COMPONENT_IMPLEMENTATION" ] | |
233 public_deps = [ | |
234 ":cloud_policy_code_generate", | |
235 ":cloud_policy_proto_generated_compile", | |
236 "//base", | |
237 "//third_party/protobuf:protobuf_lite", | |
238 ] | |
239 } | |
240 | |
241 if (gen_policy_templates_android && is_android) { | |
242 import("//build/config/android/rules.gni") | |
243 | |
244 _generated_resources_dir = "$root_gen_dir/chrome/app/policy/android" | |
245 | |
246 copy("app_restrictions_resources_copy") { | |
247 sources = [ | |
248 app_restrictions_path, | |
249 ] | |
250 outputs = [ | |
251 "$_generated_resources_dir/xml-v21/app_restrictions.xml", | |
252 ] | |
253 deps = [ | |
254 ":cloud_policy_code_generate", | |
255 ":policy_templates", | |
256 ] | |
257 } | |
258 | |
259 android_resources("app_restrictions_resources") { | |
260 resource_dirs = [] | |
261 generated_resource_dirs = [ | |
262 "$policy_templates_base_dir/android", | |
263 _generated_resources_dir, | |
264 ] | |
265 generated_resource_files = | |
266 policy_templates_android_outputs + | |
267 [ "$_generated_resources_dir/xml-v21/app_restrictions.xml" ] | |
268 deps = [ | |
269 ":app_restrictions_resources_copy", | |
270 ":grit_policy_templates", | |
271 ] | |
272 } | |
273 } else if (gen_policy_templates_mac && is_mac) { | |
274 action("convert_mcx_plist") { | |
275 script = "//build/config/mac/xcrun.py" | |
276 sources = [ | |
277 "$policy_templates_base_dir/mac/app-Manifest.plist", | |
278 ] | |
279 inputs = [ | |
280 script, | |
281 ] | |
282 outputs = [ | |
283 "$target_gen_dir/$chrome_mac_bundle_id.manifest", | |
284 ] | |
285 | |
286 if (use_system_xcode) { | |
287 args = [] | |
288 } else { | |
289 args = [ | |
290 "--developer_dir", | |
291 hermetic_xcode_path, | |
292 ] | |
293 } | |
294 args += [ | |
295 "plutil", | |
296 "-convert", | |
297 "xml1", | |
298 ] + rebase_path(sources, root_out_dir) + [ "-o" ] + | |
299 rebase_path(outputs, root_out_dir) | |
300 | |
301 deps = [ | |
302 ":policy_templates", | |
303 ] | |
304 } | |
305 | |
306 bundle_data("manifest_bundle_data") { | |
307 sources = get_target_outputs(":convert_mcx_plist") | |
308 outputs = [ | |
309 "{{bundle_resources_dir}}/{{source_file_part}}", | |
310 ] | |
311 public_deps = [ | |
312 ":convert_mcx_plist", | |
313 ] | |
314 } | |
315 | |
316 # The reason we are not enumerating all the locales is that | |
317 # the translations would eat up 3.5MB disk space in the | |
318 # application bundle. | |
319 bundle_data("manifest_strings_bundle_data") { | |
320 sources = [ | |
321 "$policy_templates_base_dir/mac/strings/en.lproj/Localizable.strings", | |
322 ] | |
323 outputs = [ | |
324 "{{bundle_resources_dir}}/en.lproj/{{source_file_part}}", | |
325 ] | |
326 public_deps = [ | |
327 ":policy_templates", | |
328 ] | |
329 } | |
330 | |
331 create_bundle("chrome_manifest_bundle") { | |
332 bundle_root_dir = "$root_out_dir/$chrome_mac_bundle_id.manifest/Contents" | |
333 bundle_resources_dir = "$bundle_root_dir/Resources" | |
334 | |
335 deps = [ | |
336 ":manifest_bundle_data", | |
337 ":manifest_strings_bundle_data", | |
338 ] | |
339 } | |
340 } | |
341 | |
342 if (gen_policy_templates_common && gen_policy_templates_win) { | |
343 version_file = "VERSION" | |
344 version_path = "$policy_templates_base_dir/$version_file" | |
345 | |
346 copy("add_version") { | |
347 sources = [ | |
348 "//chrome/VERSION", | |
349 ] | |
350 outputs = [ | |
351 version_path, | |
352 ] | |
353 } | |
354 | |
355 action("pack_policy_templates") { | |
356 output_zip_file = "$root_out_dir/policy_templates.zip" | |
357 script = "tools/make_policy_zip.py" | |
358 inputs = | |
359 [ | |
360 version_path, | |
361 policy_templates_grd_file, | |
362 grit_info_script, | |
363 ] + policy_templates_windows_outputs + policy_templates_doc_outputs | |
364 outputs = [ | |
365 output_zip_file, | |
366 ] | |
367 args = [ | |
368 "--output", | |
369 rebase_path(output_zip_file, root_build_dir), | |
370 "--basedir", | |
371 rebase_path(policy_templates_base_dir, root_build_dir), | |
372 "--grd_input", | |
373 rebase_path(policy_templates_grd_file, root_build_dir), | |
374 "--grd_strip_path_prefix", | |
375 "app/policy", | |
376 "--extra_input", | |
377 version_file, | |
378 "--grit_info", | |
379 rebase_path(grit_info_script, root_build_dir), | |
380 "-D", | |
381 "gen_policy_templates_common", | |
382 "-D", | |
383 "gen_policy_templates_win", | |
384 ] + grit_defines | |
385 if (is_chrome_branded) { | |
386 args += [ "--include_google_admx" ] | |
387 } | |
388 deps = [ | |
389 ":add_version", | |
390 ":policy_templates", | |
391 ] | |
392 } | |
393 } | |
394 } | |
OLD | NEW |