Add support for Mac/iOS application bundles to GN tool.

tools/gn/functions_target.cc

 // Copyright (c) 2013 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.
 
 #include "tools/gn/functions.h"
 
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/target_generator.h"
 #include "tools/gn/template.h"
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 
 #define DEPENDENT_CONFIG_VARS \
     "  Dependent configs: all_dependent_configs, public_configs\n"
 #define DEPS_VARS \
     "  Deps: data_deps, deps, public_deps\n"
 #define GENERAL_TARGET_VARS \
-    "  General: check_includes, configs, data, inputs, output_name,\n" \
-    "           output_extension, public, sources, testonly, visibility\n"
+    "  General: bundle_data, check_includes, configs, data, inputs,\n" \
+    "           output_name, output_extension, public, sources, testonly,\n" \
+    "           visibility\n"
 
 namespace functions {
 
 namespace {
 
 Value ExecuteGenericTarget(const char* target_type,
                            Scope* scope,
                            const FunctionCallNode* function,
                            const std::vector<Value>& args,
                            BlockNode* block,
@@ skipping 259 matching lines @@
               const std::vector<Value>& args,
               Scope* scope,
               Err* err) {
   if (!EnsureNotProcessingImport(function, scope, err) ||
       !EnsureNotProcessingBuildConfig(function, scope, err))
     return Value();
   TargetGenerator::GenerateTarget(scope, function, args, functions::kCopy, err);
   return Value();
 }
 
+// copy bundle data ------------------------------------------------------------
+
+const char kCopyBundleData[] = "copy_bundle_data";
+const char kCopyBundleData_HelpShort[] =
+    "copy_bundle_data: Declare a target that copy \"bundle_data\" files.";
+const char kCopyBundleData_Help[] =
+    "copy_bundle_data: Declare a target that copy \"bundle_data\" files.\n"
+    "\n"
+    "  Similar to the \"copy\" target, but the list of files to copy comes\n"
+    "  from the \"bundle_data\" property of all dependencies recursively.\n"
+    "  It can be used to copy files required at runtime by the application\n"
+    "  into a location where it can be found.\n"
+    "\n"
+    "  This uses the \"copy_bundle_data\" tool from the toolchain.\n"
+    "\n"
+    "  See \"gn help copy\" for more information.\n"
+    "\n"
+    "Examples\n"
+    "\n"
+    "  # A source_set that has a runtime dependency expressed as bundle_data\n"
+    "  source_set(\"icu\") {\n"
+    "    sources = [ \"icu.h\", \"icu.cc\" ]\n"
+    "    bundle_data = [ \"icudtl.dat\" ]\n"
+    "  }\n"
+    "\n"
+    "  # Main application executable.\n"
+    "  executable(\"app.app\") {\n"
+    "    visibility = [ \":app\" ]\n"
+    "    deps = [ \":icu\" ]\n"
+    "    output_name = \"$root_build_dir/app.app/app\"\n"
+    "    sources = [ \"main.cc\" ]\n"
+    "  }\n"
+    "\n"
+    "  # Copy runtime dependencies into the application bundle, filtering\n"
+    "  # the .xcassets files as they need to be compiled into a .car file\n"
+    "  # on Mac/iOS.\n"
+    "  copy_bundle_data(\"app.bundle\") {\n"
+    "    visibility = [ \":app\" ]\n"
+    "    deps = [ \":icu\" ]  # Same deps as the executable.\n"
+    "    outputs = [ $root_build_dir/app.app/{{source_file_name}}\" ]\n"
+    "    bundle_data_filter = [ \"*.xcassets\" ]\n"
+    "  }\n"
+    "\n"
+    "  # Main application target.\n"
+    "  group(\"app\") {\n"
+    "    deps = [ \":app.app\", \"app.bundle\" ]\n"
+    "  }\n"
+    "";
+
+Value RunCopyBundleData(const FunctionCallNode* function,
+                        const std::vector<Value>& args,
+                        Scope* scope,
+                        Err* err) {
+  if (!EnsureNotProcessingImport(function, scope, err) ||
+      !EnsureNotProcessingBuildConfig(function, scope, err))
+    return Value();
+  TargetGenerator::GenerateTarget(scope, function, args,
+                                  functions::kCopyBundleData, err);
+  return Value();
+}
+
 // executable ------------------------------------------------------------------
 
 const char kExecutable[] = "executable";
 const char kExecutable_HelpShort[] =
     "executable: Declare an executable target.";
 const char kExecutable_Help[] =
     "executable: Declare an executable target.\n"
     "\n"
     "Variables\n"
     "\n"
@@ skipping 245 matching lines @@
   const Template* templ = scope->GetTemplate(target_type);
   if (templ)
     return templ->Invoke(scope, function, sub_args, block, err);
 
   // Otherwise, assume the target is a built-in target type.
   return ExecuteGenericTarget(target_type.c_str(), scope, function, sub_args,
                               block, err);
 }
 
 }  // namespace functions