Build Mojo apps in subdirectories, like application packages.

mojo/public/mojo_application.gni

 # 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("mojo.gni")
 
-# Generate a binary mojo application.The parameters of this template are those
-# of a shared library.
+# Generate a binary Mojo application in a self-named directory.
+# Application resources are copied to a "resources" directory alongside the app.
+# The parameters of this template are those of a shared library.
 template("mojo_native_application") {
+  base_target_name = target_name
   if (defined(invoker.output_name)) {
     base_target_name = invoker.output_name
-  } else {
-    base_target_name = target_name
   }
 
   final_target_name = target_name
 
+  mojo_deps = []
+  if (defined(invoker.deps)) {
+    mojo_deps += invoker.deps
+  }
+
+  if (defined(invoker.resources)) {
+    copy_step_name = "${base_target_name}__copy_resources"
+    copy(copy_step_name) {
+      sources = invoker.resources
+      outputs = [
+        "${root_out_dir}/${base_target_name}/resources/{{source_file_part}}",
+      ]
+      if (defined(invoker.testonly)) {
+        testonly = invoker.testonly
+      }
+      deps = mojo_deps
+    }
+    mojo_deps += [ ":$copy_step_name" ]
+  }
+
   if (!is_nacl) {
     output = base_target_name + ".mojo"
     library_target_name = base_target_name + "_library"
 
     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) {
       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.
+      # 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) {
       if (defined(invoker.cflags)) {
         cflags = invoker.cflags
       }
       if (defined(invoker.cflags_c)) {
@@ skipping 39 matching lines @@
                                    ".",
                                    mojo_root) ]
       }
 
       deps = rebase_path([
                            "mojo/public/c/system",
                            "mojo/public/platform/native:system",
                          ],
                          ".",
                          mojo_root)
-      if (defined(invoker.deps)) {
-        deps += invoker.deps
-      }
+      deps += mojo_deps
       if (defined(invoker.forward_dependent_configs_from)) {
         forward_dependent_configs_from = invoker.forward_dependent_configs_from
       }
       if (defined(invoker.public_deps)) {
         public_deps = invoker.public_deps
       }
       if (defined(invoker.all_dependent_configs)) {
         all_dependent_configs = invoker.all_dependent_configs
       }
       if (defined(invoker.public_configs)) {
@@ skipping 32 matching lines @@
         visibility = invoker.visibility
       }
       deps = [
         ":${library_target_name}",
       ]
 
       sources = [
         "${library_dir}/${library_name}",
       ]
       outputs = [
-        "${root_out_dir}/${output}",
+        "${root_out_dir}/${base_target_name}/${output}",
       ]
     }
   } else {
     nexe_target_name = base_target_name + "_nexe"
     nexe_name = base_target_name + ".nexe"
 
     output = "${base_target_name}_${target_cpu}.nexe.mojo"
 
     executable(nexe_target_name) {
       output_name = base_target_name
@@ skipping 44 matching lines @@
                                    ".",
                                    mojo_root) ]
       }
 
       deps = rebase_path([
                            "mojo/public/c/system",
                            "mojo/public/platform/nacl:system",
                          ],
                          ".",
                          mojo_root)
-      if (defined(invoker.deps)) {
-        deps += invoker.deps
-      }
+      deps += mojo_deps
       if (defined(invoker.forward_dependent_configs_from)) {
         forward_dependent_configs_from = invoker.forward_dependent_configs_from
       }
       if (defined(invoker.public_deps)) {
         public_deps = invoker.public_deps
       }
       if (defined(invoker.all_dependent_configs)) {
         all_dependent_configs = invoker.all_dependent_configs
       }
       if (defined(invoker.public_configs)) {
@@ skipping 32 matching lines @@
         visibility = invoker.visibility
       }
 
       script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_root)
 
       input_path = "${root_out_dir}/${nexe_name}"
       inputs = [
         input_path,
       ]
 
-      output_path = "${root_build_dir}/${output}"
+      output_path = "${root_build_dir}/${base_target_name}/${output}"
       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)
@@ skipping 49 matching lines @@
         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(target_name) {
       script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_root)
 
+      base_target_name = target_name
+      if (defined(invoker.output_name)) {
+        base_target_name = invoker.output_name
+      }
+
       input = zip_action_output
       inputs = [
         input,
       ]
 
-      output = mojo_output
+      output = "${root_out_dir}/${base_target_name}/${base_target_name}.mojo"
       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",
       ]
 
       public_deps = [
         ":$zip_action_name",
       ]
     }
   }
 }