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