| # 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. |
| |
| import("//build/module_args/mojo.gni") |
| import("mojo.gni") |
| import("mojo_sdk.gni") |
| |
| # Generate a binary mojo application.The parameters of this template are those |
| # of a shared library. |
| template("mojo_native_application") { |
| if (defined(invoker.output_name)) { |
| base_target_name = invoker.output_name |
| } else { |
| base_target_name = target_name |
| } |
| |
| if (!is_nacl) { |
| final_target_name = target_name |
| output = base_target_name + ".mojo" |
| library_target_name = base_target_name + "_library" |
| copy_symbols_target = "__${final_target_name}_copy_symbols" |
| |
| if (is_linux || is_android) { |
| library_name = "lib${library_target_name}.so" |
| } else if (is_win) { |
| library_name = "${library_target_name}.dll" |
| } else if (is_mac || is_ios) { |
| library_name = "lib${library_target_name}.dylib" |
| } else { |
| assert(false, "Platform not supported.") |
| } |
| |
| if (is_android) { |
| # On android, use the stripped version of the library, because applications |
| # are always fetched over the network. |
| library_dir = "${root_out_dir}/lib.stripped" |
| } else { |
| library_dir = root_out_dir |
| } |
| |
| shared_library(library_target_name) { |
| data_deps = [] |
| forward_variables_from(invoker, |
| [ |
| "cflags", |
| "cflags_c", |
| "cflags_cc", |
| "cflags_objc", |
| "cflags_objcc", |
| "defines", |
| "include_dirs", |
| "ldflags", |
| "lib_dirs", |
| "libs", |
| "data_deps", |
| ]) |
| |
| # Copy any necessary prebuilt artifacts. |
| if (mojo_use_prebuilt_mojo_shell) { |
| data_deps += |
| [ rebase_path("mojo/public/tools:copy_mojo_shell", ".", mojo_root) ] |
| } |
| if (mojo_use_prebuilt_network_service) { |
| data_deps += [ rebase_path("mojo/public/tools:copy_network_service", |
| ".", |
| mojo_root) ] |
| } |
| |
| deps = |
| rebase_path([ "mojo/public/platform/native:system" ], ".", mojo_root) |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| if (defined(invoker.configs)) { |
| configs += invoker.configs |
| } |
| forward_variables_from(invoker, |
| [ |
| "public_deps", |
| "all_dependent_configs", |
| "public_configs", |
| "check_includes", |
| "data", |
| "inputs", |
| "public", |
| "sources", |
| "testonly", |
| ]) |
| |
| visibility = [ |
| ":${final_target_name}", |
| ":${copy_symbols_target}", |
| ] |
| } |
| |
| copy(copy_symbols_target) { |
| if (defined(invoker.testonly)) { |
| testonly = invoker.testonly |
| } |
| visibility = [ ":${final_target_name}" ] |
| deps = [ |
| ":${library_target_name}", |
| ] |
| |
| sources = [ |
| "${root_out_dir}/${library_name}", |
| ] |
| outputs = [ |
| "${root_out_dir}/symbols/${library_name}", |
| ] |
| } |
| |
| copy(final_target_name) { |
| forward_variables_from(invoker, |
| [ |
| "testonly", |
| "visibility", |
| ]) |
| |
| public_deps = [ |
| # We want to allow rules to depend on symbol libraries. |
| ":${copy_symbols_target}", |
| ] |
| |
| deps = [ |
| ":${library_target_name}", |
| ] |
| |
| sources = [ |
| "${library_dir}/${library_name}", |
| ] |
| outputs = [ |
| "${root_out_dir}/${output}", |
| ] |
| } |
| } else { |
| nexe_target_name = base_target_name + "_nexe" |
| executable_target_name = base_target_name + "_exe" |
| |
| executable(nexe_target_name) { |
| output_name = base_target_name |
| data_deps = [] |
| forward_variables_from(invoker, |
| [ |
| "cflags", |
| "cflags_c", |
| "cflags_cc", |
| "cflags_objc", |
| "cflags_objcc", |
| "defines", |
| "include_dirs", |
| "ldflags", |
| "lib_dirs", |
| "libs", |
| "data_deps", |
| ]) |
| |
| # Copy any necessary prebuilt artifacts. |
| if (mojo_use_prebuilt_mojo_shell) { |
| data_deps += |
| [ rebase_path("mojo/public/tools:copy_mojo_shell", ".", mojo_root) ] |
| } |
| if (mojo_use_prebuilt_network_service) { |
| data_deps += [ rebase_path("mojo/public/tools:copy_network_service", |
| ".", |
| mojo_root) ] |
| } |
| |
| deps = rebase_path([ |
| "mojo/public/c/system", |
| "mojo/public/platform/nacl:system", |
| ], |
| ".", |
| mojo_root) |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| if (defined(invoker.configs)) { |
| configs += invoker.configs |
| } |
| |
| forward_variables_from(invoker, |
| [ |
| "forward_dependent_configs_from", |
| "public_deps", |
| "all_dependent_configs", |
| "public_configs", |
| "check_includes", |
| "data", |
| "inputs", |
| "public", |
| "sources", |
| "testonly", |
| ]) |
| |
| visibility = [ ":*" ] |
| } |
| |
| group(target_name) { |
| # This group specifies two targets: first, it requests that the |
| # pexe be built, and secondly (if the toolchain is not requesting |
| # a pexe implicitly), it creates a nexe. |
| forward_variables_from(invoker, [ "testonly" ]) |
| deps = [ |
| ":${executable_target_name}(//build/toolchain/nacl:newlib_pnacl)", |
| ] |
| if (current_cpu != "pnacl") { |
| deps += [ ":${executable_target_name}" ] |
| } |
| } |
| |
| action(executable_target_name) { |
| if (current_cpu == "pnacl") { |
| input_file_extension = ".pexe" |
| output_file_extension = ".pexe.mojo" |
| content_handler = "content_handler_nonsfi_pexe" |
| } else { |
| input_file_extension = ".nexe" |
| output_file_extension = "_${target_cpu}.nexe.mojo" |
| content_handler = "content_handler_sfi_nexe" |
| } |
| input_file = "${base_target_name}${input_file_extension}" |
| output_file = "${base_target_name}${output_file_extension}" |
| |
| forward_variables_from(invoker, |
| [ |
| "testonly", |
| "visibility", |
| ]) |
| |
| script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_root) |
| |
| input_path = "${root_out_dir}/${input_file}" |
| inputs = [ |
| input_path, |
| ] |
| |
| output_path = "${root_build_dir}/${output_file}" |
| outputs = [ |
| output_path, |
| ] |
| |
| deps = [ |
| ":${nexe_target_name}", |
| ] |
| |
| rebase_input = rebase_path(input_path, root_build_dir) |
| rebase_output = rebase_path(output_path, root_build_dir) |
| args = [ |
| "--input=$rebase_input", |
| "--output=$rebase_output", |
| "--line=#!mojo mojo:$content_handler", |
| ] |
| } |
| } |
| } |
| |
| if (is_android) { |
| import("//build/config/android/rules.gni") |
| |
| # Declares an Android Mojo application consisting of an .so file and a |
| # corresponding .dex.jar file. |
| # |
| # Variables: |
| # sources (optional): The c++ sources. |
| # deps (optional): The c++ dependencies. |
| # java_sources (optional): The java sources. |
| # java_deps (optional): The java dependencies. |
| # jni_package (optional): The c++ package for the generated jni headers. |
| # output_name (optional): override for the output file name |
| # public_deps / data_deps (optional): Dependencies. |
| template("mojo_android_application") { |
| shared_library_name = "__${target_name}_lib" |
| library_basename = "lib${shared_library_name}.so" |
| if (defined(invoker.jni_package)) { |
| assert(defined(invoker.java_sources)) |
| generate_jni_name = "__${target_name}_jni" |
| } |
| if (defined(invoker.java_sources)) { |
| java_library_name = "__${target_name}_java" |
| } |
| android_standalone_library_name = "__${target_name}_java_lib" |
| dex_output_path = "${target_gen_dir}/${target_name}.dex.jar" |
| zip_action_name = "__${target_name}_zip" |
| zip_action_output = "${target_gen_dir}/${target_name}.zip" |
| copy_symbols_target = "__${target_name}_copy_symbols" |
| final_target_name = target_name |
| |
| if (defined(invoker.jni_package)) { |
| generate_jni(generate_jni_name) { |
| visibility = [ ":${shared_library_name}" ] |
| |
| sources = invoker.java_sources |
| jni_package = invoker.jni_package |
| } |
| } |
| |
| shared_library(shared_library_name) { |
| visibility = [ |
| ":${copy_symbols_target}", |
| ":${zip_action_name}", |
| ] |
| |
| if (defined(invoker.sources)) { |
| sources = invoker.sources |
| } |
| |
| deps = |
| rebase_path([ "mojo/public/platform/native:system" ], ".", mojo_root) |
| if (defined(invoker.jni_package)) { |
| deps += [ ":${generate_jni_name}" ] |
| } |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| } |
| |
| copy(copy_symbols_target) { |
| visibility = [ ":${final_target_name}" ] |
| deps = [ |
| ":${shared_library_name}", |
| ] |
| |
| sources = [ |
| "${root_out_dir}/${library_basename}", |
| ] |
| outputs = [ |
| "${root_out_dir}/symbols/${library_basename}", |
| ] |
| } |
| |
| if (defined(invoker.java_sources)) { |
| android_library(java_library_name) { |
| visibility = [ ":*" ] |
| |
| java_files = invoker.java_sources |
| |
| if (defined(invoker.java_deps)) { |
| deps = invoker.java_deps |
| } |
| } |
| } |
| |
| android_standalone_library(android_standalone_library_name) { |
| deps = [] |
| |
| if (defined(invoker.java_sources)) { |
| deps += [ ":${java_library_name}" ] |
| } |
| |
| if (defined(invoker.java_deps)) { |
| deps += invoker.java_deps |
| } |
| |
| dex_path = dex_output_path |
| } |
| |
| action(zip_action_name) { |
| visibility = [ ":${final_target_name}" ] |
| script = "//build/android/gn/zip.py" |
| |
| inputs = [ |
| "${root_out_dir}/lib.stripped/${library_basename}", |
| dex_output_path, |
| ] |
| |
| output = zip_action_output |
| outputs = [ |
| output, |
| ] |
| |
| rebase_inputs = rebase_path(inputs, root_build_dir) |
| rebase_output = rebase_path(output, root_build_dir) |
| args = [ |
| "--inputs=${rebase_inputs}", |
| "--output=${rebase_output}", |
| ] |
| |
| deps = [ |
| ":${android_standalone_library_name}", |
| ":${shared_library_name}", |
| ] |
| |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| if (defined(invoker.public_deps)) { |
| public_deps = invoker.public_deps |
| } |
| if (defined(invoker.data_deps)) { |
| data_deps = invoker.data_deps |
| } |
| } |
| |
| if (defined(invoker.output_name)) { |
| mojo_output = "${root_out_dir}/" + invoker.output_name + ".mojo" |
| } else { |
| mojo_output = "${root_out_dir}/" + target_name + ".mojo" |
| } |
| |
| action(final_target_name) { |
| script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_root) |
| |
| input = zip_action_output |
| inputs = [ |
| input, |
| ] |
| |
| output = mojo_output |
| outputs = [ |
| output, |
| ] |
| |
| rebase_input = rebase_path(input, root_build_dir) |
| rebase_output = rebase_path(output, root_build_dir) |
| args = [ |
| "--input=${rebase_input}", |
| "--output=${rebase_output}", |
| "--line=#!mojo mojo:android_handler", |
| ] |
| |
| deps = [ |
| ":${copy_symbols_target}", |
| ] |
| |
| public_deps = [ |
| ":${zip_action_name}", |
| ] |
| } |
| } |
| } |
