mojo/public/mojo_application.gni

   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.
   4
   5 import("mojo.gni")
   6 if (is_android) {
   7   import("//build/config/android/config.gni")
   8 }
   9
  10 # Generate a binary Mojo application in a self-named directory.
  11 # Application resources are copied to a "resources" directory alongside the app.
  12 # The parameters of this template are those of a shared library.
  13 template("mojo_native_application") {
  14   base_target_name = target_name
  15   if (defined(invoker.output_name)) {
  16     base_target_name = invoker.output_name
  17   }
  18
  19   final_target_name = target_name
  20
  21   mojo_deps = []
  22   if (defined(invoker.deps)) {
  23     mojo_deps += invoker.deps
  24   }
  25
  26   if (defined(invoker.resources)) {
  27     copy_step_name = "${base_target_name}__copy_resources"
  28     copy(copy_step_name) {
  29       sources = invoker.resources
  30       outputs = [
  31         "${root_out_dir}/${base_target_name}/resources/{{source_file_part}}",
  32       ]
  33       if (defined(invoker.testonly)) {
  34         testonly = invoker.testonly
  35       }
  36       deps = mojo_deps
  37     }
  38     mojo_deps += [ ":$copy_step_name" ]
  39   }
  40
  41   if (!is_nacl) {
  42     output = base_target_name + ".mojo"
  43     library_target_name = base_target_name + "_library"
  44
  45     if (is_linux) {
  46       library_name = "lib${library_target_name}.so"
  47     } else if (is_android) {
  48       library_name = "lib${library_target_name}${android_product_extension}"
  49     } else if (is_win) {
  50       library_name = "${library_target_name}.dll"
  51     } else if (is_mac) {
  52       library_name = "lib${library_target_name}.dylib"
  53     } else {
  54       assert(false, "Platform not supported.")
  55     }
  56
  57     if (is_android) {
  58       # On android, use the stripped version of the library, because
  59       # applications are always fetched over the network.
  60       library_dir = "${root_out_dir}/lib.stripped"
  61     } else {
  62       library_dir = root_out_dir
  63     }
  64
  65     shared_library(library_target_name) {
  66       if (defined(invoker.cflags)) {
  67         cflags = invoker.cflags
  68       }
  69       if (defined(invoker.cflags_c)) {
  70         cflags_c = invoker.cflags_c
  71       }
  72       if (defined(invoker.cflags_cc)) {
  73         cflags_cc = invoker.cflags_cc
  74       }
  75       if (defined(invoker.cflags_objc)) {
  76         cflags_objc = invoker.cflags_objc
  77       }
  78       if (defined(invoker.cflags_objcc)) {
  79         cflags_objcc = invoker.cflags_objcc
  80       }
  81       if (defined(invoker.defines)) {
  82         defines = invoker.defines
  83       }
  84       if (defined(invoker.include_dirs)) {
  85         include_dirs = invoker.include_dirs
  86       }
  87       if (defined(invoker.ldflags)) {
  88         ldflags = invoker.ldflags
  89       }
  90       if (defined(invoker.lib_dirs)) {
  91         lib_dirs = invoker.lib_dirs
  92       }
  93       if (defined(invoker.libs)) {
  94         libs = invoker.libs
  95       }
  96
  97       data_deps = []
  98       if (defined(invoker.data_deps)) {
  99         data_deps = invoker.data_deps
 100       }
 101
 102       # Copy any necessary prebuilt artifacts.
 103       if (mojo_use_prebuilt_mojo_shell) {
 104         data_deps +=
 105             [ rebase_path("mojo/public/tools:copy_mojo_shell", ".", mojo_root) ]
 106       }
 107       if (mojo_use_prebuilt_network_service) {
 108         data_deps += [ rebase_path("mojo/public/tools:copy_network_service",
 109                                    ".",
 110                                    mojo_root) ]
 111       }
 112
 113       deps = rebase_path([
 114                            "mojo/public/c/system",
 115                            "mojo/public/platform/native:system",
 116                          ],
 117                          ".",
 118                          mojo_root)
 119       deps += mojo_deps
 120       if (defined(invoker.forward_dependent_configs_from)) {
 121         forward_dependent_configs_from = invoker.forward_dependent_configs_from
 122       }
 123       if (defined(invoker.public_deps)) {
 124         public_deps = invoker.public_deps
 125       }
 126       if (defined(invoker.all_dependent_configs)) {
 127         all_dependent_configs = invoker.all_dependent_configs
 128       }
 129       if (defined(invoker.public_configs)) {
 130         public_configs = invoker.public_configs
 131       }
 132       if (defined(invoker.check_includes)) {
 133         check_includes = invoker.check_includes
 134       }
 135       if (defined(invoker.configs)) {
 136         configs += invoker.configs
 137       }
 138       if (defined(invoker.data)) {
 139         data = invoker.data
 140       }
 141       if (defined(invoker.inputs)) {
 142         inputs = invoker.inputs
 143       }
 144       if (defined(invoker.public)) {
 145         public = invoker.public
 146       }
 147       if (defined(invoker.sources)) {
 148         sources = invoker.sources
 149       }
 150       if (defined(invoker.testonly)) {
 151         testonly = invoker.testonly
 152       }
 153
 154       visibility = [ ":${final_target_name}" ]
 155     }
 156
 157     copy(final_target_name) {
 158       if (defined(invoker.testonly)) {
 159         testonly = invoker.testonly
 160       }
 161       if (defined(invoker.visibility)) {
 162         visibility = invoker.visibility
 163       }
 164       deps = [
 165         ":${library_target_name}",
 166       ]
 167
 168       sources = [
 169         "${library_dir}/${library_name}",
 170       ]
 171       outputs = [
 172         "${root_out_dir}/${base_target_name}/${output}",
 173       ]
 174     }
 175   } else {
 176     nexe_target_name = base_target_name + "_nexe"
 177     nexe_name = base_target_name + ".nexe"
 178
 179     output = "${base_target_name}_${target_cpu}.nexe.mojo"
 180
 181     executable(nexe_target_name) {
 182       output_name = base_target_name
 183
 184       if (defined(invoker.cflags)) {
 185         cflags = invoker.cflags
 186       }
 187       if (defined(invoker.cflags_c)) {
 188         cflags_c = invoker.cflags_c
 189       }
 190       if (defined(invoker.cflags_cc)) {
 191         cflags_cc = invoker.cflags_cc
 192       }
 193       if (defined(invoker.cflags_objc)) {
 194         cflags_objc = invoker.cflags_objc
 195       }
 196       if (defined(invoker.cflags_objcc)) {
 197         cflags_objcc = invoker.cflags_objcc
 198       }
 199       if (defined(invoker.defines)) {
 200         defines = invoker.defines
 201       }
 202       if (defined(invoker.include_dirs)) {
 203         include_dirs = invoker.include_dirs
 204       }
 205       if (defined(invoker.ldflags)) {
 206         ldflags = invoker.ldflags
 207       }
 208       if (defined(invoker.lib_dirs)) {
 209         lib_dirs = invoker.lib_dirs
 210       }
 211       if (defined(invoker.libs)) {
 212         libs = invoker.libs
 213       }
 214
 215       data_deps = []
 216       if (defined(invoker.data_deps)) {
 217         data_deps = invoker.data_deps
 218       }
 219
 220       # Copy any necessary prebuilt artifacts.
 221       if (mojo_use_prebuilt_mojo_shell) {
 222         data_deps +=
 223             [ rebase_path("mojo/public/tools:copy_mojo_shell", ".", mojo_root) ]
 224       }
 225       if (mojo_use_prebuilt_network_service) {
 226         data_deps += [ rebase_path("mojo/public/tools:copy_network_service",
 227                                    ".",
 228                                    mojo_root) ]
 229       }
 230
 231       deps = rebase_path([
 232                            "mojo/public/c/system",
 233                            "mojo/public/platform/nacl:system",
 234                          ],
 235                          ".",
 236                          mojo_root)
 237       deps += mojo_deps
 238       if (defined(invoker.forward_dependent_configs_from)) {
 239         forward_dependent_configs_from = invoker.forward_dependent_configs_from
 240       }
 241       if (defined(invoker.public_deps)) {
 242         public_deps = invoker.public_deps
 243       }
 244       if (defined(invoker.all_dependent_configs)) {
 245         all_dependent_configs = invoker.all_dependent_configs
 246       }
 247       if (defined(invoker.public_configs)) {
 248         public_configs = invoker.public_configs
 249       }
 250       if (defined(invoker.check_includes)) {
 251         check_includes = invoker.check_includes
 252       }
 253       if (defined(invoker.configs)) {
 254         configs += invoker.configs
 255       }
 256       if (defined(invoker.data)) {
 257         data = invoker.data
 258       }
 259       if (defined(invoker.inputs)) {
 260         inputs = invoker.inputs
 261       }
 262       if (defined(invoker.public)) {
 263         public = invoker.public
 264       }
 265       if (defined(invoker.sources)) {
 266         sources = invoker.sources
 267       }
 268       if (defined(invoker.testonly)) {
 269         testonly = invoker.testonly
 270       }
 271
 272       visibility = [ ":${final_target_name}" ]
 273     }
 274
 275     action(target_name) {
 276       if (defined(invoker.testonly)) {
 277         testonly = invoker.testonly
 278       }
 279       if (defined(invoker.visibility)) {
 280         visibility = invoker.visibility
 281       }
 282
 283       script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_root)
 284
 285       input_path = "${root_out_dir}/${nexe_name}"
 286       inputs = [
 287         input_path,
 288       ]
 289
 290       output_path = "${root_build_dir}/${base_target_name}/${output}"
 291       outputs = [
 292         output_path,
 293       ]
 294
 295       deps = [
 296         ":${nexe_target_name}",
 297       ]
 298
 299       rebase_input = rebase_path(input_path, root_build_dir)
 300       rebase_output = rebase_path(output_path, root_build_dir)
 301       args = [
 302         "--input=$rebase_input",
 303         "--output=$rebase_output",
 304         "--line=#!mojo mojo:nacl_content_handler",
 305       ]
 306     }
 307   }
 308 }
 309
 310 if (is_android) {
 311   # Declares an Android Mojo application consisting of an .so file and a
 312   # corresponding .dex.jar file.
 313   #
 314   # Variables:
 315   #   input_so: the .so file to bundle
 316   #   input_dex_jar: the .dex.jar file to bundle
 317   #   deps / public_deps / data_deps (optional):
 318   #       Dependencies. The targets that generate the .so/jar inputs should be
 319   #       listed in either deps or public_deps.
 320   #   output_name (optional): override for the output file name
 321   template("mojo_android_application") {
 322     assert(defined(invoker.input_so))
 323     assert(defined(invoker.input_dex_jar))
 324
 325     mojo_deps = []
 326     if (defined(invoker.resources)) {
 327       base_target_name = target_name
 328       if (defined(invoker.output_name)) {
 329         base_target_name = invoker.output_name
 330       }
 331
 332       copy_step_name = "${base_target_name}__copy_resources"
 333       copy(copy_step_name) {
 334         sources = invoker.resources
 335         outputs = [
 336           "${root_out_dir}/${base_target_name}/resources/{{source_file_part}}",
 337         ]
 338         if (defined(invoker.testonly)) {
 339           testonly = invoker.testonly
 340         }
 341         if (defined(invoker.deps)) {
 342           deps = invoker.deps
 343         }
 344       }
 345       mojo_deps += [ ":$copy_step_name" ]
 346     }
 347
 348     zip_action_name = "${target_name}_zip"
 349     zip_action_output = "$target_gen_dir/${target_name}.zip"
 350     prepend_action_name = target_name
 351     action(zip_action_name) {
 352       visibility = [ ":$prepend_action_name" ]
 353       script = "//build/android/gn/zip.py"
 354
 355       inputs = [
 356         invoker.input_so,
 357         invoker.input_dex_jar,
 358       ]
 359
 360       output = zip_action_output
 361       outputs = [
 362         output,
 363       ]
 364
 365       rebase_inputs = rebase_path(inputs, root_build_dir)
 366       rebase_output = rebase_path(output, root_build_dir)
 367       args = [
 368         "--inputs=$rebase_inputs",
 369         "--output=$rebase_output",
 370       ]
 371
 372       if (defined(invoker.deps)) {
 373         deps = invoker.deps
 374       }
 375       if (defined(invoker.public_deps)) {
 376         public_deps = invoker.public_deps
 377       }
 378       if (defined(invoker.data_deps)) {
 379         data_deps = invoker.data_deps
 380       }
 381     }
 382
 383     action(target_name) {
 384       script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_root)
 385
 386       base_target_name = target_name
 387       if (defined(invoker.output_name)) {
 388         base_target_name = invoker.output_name
 389       }
 390
 391       input = zip_action_output
 392       inputs = [
 393         input,
 394       ]
 395
 396       output = "${root_out_dir}/${base_target_name}/${base_target_name}.mojo"
 397       outputs = [
 398         output,
 399       ]
 400
 401       rebase_input = rebase_path(input, root_build_dir)
 402       rebase_output = rebase_path(output, root_build_dir)
 403       args = [
 404         "--input=$rebase_input",
 405         "--output=$rebase_output",
 406         "--line=#!mojo mojo:android_handler",
 407       ]
 408
 409       deps = mojo_deps
 410
 411       public_deps = [
 412         ":$zip_action_name",
 413       ]
 414     }
 415   }
 416 }