Add "create_bundle" target in order to support bundle with gn.

tools/gn/function_toolchain.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 <algorithm>
 #include <limits>
 #include <utility>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
@@ skipping 389 matching lines @@
     "\n"
     "    Linker tools:\n"
     "      \"alink\": Linker for static libraries (archives)\n"
     "      \"solink\": Linker for shared libraries\n"
     "      \"link\": Linker for executables\n"
     "\n"
     "    Other tools:\n"
     "      \"stamp\": Tool for creating stamp files\n"
     "      \"copy\": Tool to copy files.\n"
     "\n"
+    "    Platform specific tools:\n"
+    "      \"copy_bundle_data\": [iOS, OS X] Tool to copy files in a bundle.\n"
+    "      \"compile_xcassets\": [iOS, OS X] Tool to compile asset catalogs.\n"
+    "\n"
     "Tool variables\n"
     "\n"
     "    command  [string with substitutions]\n"
     "        Valid for: all tools (required)\n"
     "\n"
     "        The command to run.\n"
     "\n"
     "    default_output_extension  [string]\n"
     "        Valid for: linker tools\n"
     "\n"
@@ skipping 291 matching lines @@
     "        shared libraries (if the solink tool specifies a \"link_output\"\n"
     "        variable separate from the \"depend_output\").\n"
     "\n"
     "        These should generally be treated the same as libs by your tool.\n"
     "        Example: \"libfoo.so libbar.so\"\n"
     "\n"
     "  The copy tool allows the common compiler/linker substitutions, plus\n"
     "  {{source}} which is the source of the copy. The stamp tool allows\n"
     "  only the common tool substitutions.\n"
     "\n"
+    "  The copy_bundle_data and compile_xcassets tools only allows the common\n"
+    "  tool substitutions. Both tools are required to create iOS/OS X bundles\n"
+    "  and need only be defined on those platforms.\n"
+    "\n"
+    "  The copy_bundle_data tool will be called with one source and needs to\n"
+    "  copy (optionally optimizing the data representation) to its output. It\n"
+    "  may be called with a directory as input and it needs to be recursively\n"
+    "  copied.\n"
+    "\n"
+    "  The compile_xcassets tool will be called with one or more source (each\n"
+    "  an asset catalog) that needs to be compiled to a single output.\n"
+    "\n"
     "Separate linking and dependencies for shared libraries\n"
     "\n"
     "  Shared libraries are special in that not all changes to them require\n"
     "  that dependent targets be re-linked. If the shared library is changed\n"
     "  but no imports or exports are different, dependent code needn't be\n"
     "  relinked, which can speed up the build.\n"
     "\n"
     "  If your link step can output a list of exports from a shared library\n"
     "  and writes the file only if the new one is different, the timestamp of\n"
     "  this file can be used for triggering re-links, while the actual shared\n"
@@ skipping 74 matching lines @@
   // tool type. There are different validators for the "outputs" than for the
   // rest of the strings.
   bool (*subst_validator)(SubstitutionType) = nullptr;
   bool (*subst_output_validator)(SubstitutionType) = nullptr;
   if (IsCompilerTool(tool_type)) {
     subst_validator = &IsValidCompilerSubstitution;
     subst_output_validator = &IsValidCompilerOutputsSubstitution;
   } else if (IsLinkerTool(tool_type)) {
     subst_validator = &IsValidLinkerSubstitution;
     subst_output_validator = &IsValidLinkerOutputsSubstitution;
-  } else if (tool_type == Toolchain::TYPE_COPY) {
+  } else if (tool_type == Toolchain::TYPE_COPY ||
+             tool_type == Toolchain::TYPE_COPY_BUNDLE_DATA) {
     subst_validator = &IsValidCopySubstitution;
     subst_output_validator = &IsValidCopySubstitution;
+  } else if (tool_type == Toolchain::TYPE_COMPILE_XCASSETS) {
+    subst_validator = &IsValidCompileXCassetsSubstitution;
+    subst_output_validator = &IsValidCompileXCassetsSubstitution;
   } else {
     subst_validator = &IsValidToolSubstitution;
     subst_output_validator = &IsValidToolSubstitution;
   }
 
   scoped_ptr<Tool> tool(new Tool);
 
   if (!ReadPattern(&block_scope, "command", subst_validator, tool.get(),
                    &Tool::set_command, err) ||
       !ReadOutputExtension(&block_scope, tool.get(), err) ||
@@ skipping 16 matching lines @@
                   &Tool::set_output_prefix, err) ||
       !ReadPrecompiledHeaderType(&block_scope, tool.get(), err) ||
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
       !ReadPattern(&block_scope, "rspfile_content", subst_validator, tool.get(),
                    &Tool::set_rspfile_content, err)) {
     return Value();
   }
 
-  if (tool_type != Toolchain::TYPE_COPY && tool_type != Toolchain::TYPE_STAMP) {
+  if (tool_type != Toolchain::TYPE_COPY &&
+      tool_type != Toolchain::TYPE_STAMP &&
+      tool_type != Toolchain::TYPE_COPY_BUNDLE_DATA &&
+      tool_type != Toolchain::TYPE_COMPILE_XCASSETS) {
     // All tools except the copy and stamp tools should have outputs. The copy

[brettw, 2016/03/07 21:57:30]

This comment needs updating.

[sdefresne, 2016/03/08 14:33:30]

Done.

     // and stamp tool's outputs are generated internally.
     if (!ReadOutputs(&block_scope, function, subst_output_validator,
                      tool.get(), err))
       return Value();
   }
 
   // Validate that the link_output, depend_output, and runtime_link_output
   // refer to items in the outputs and aren't defined for irrelevant tool
   // types.
   if (!tool->link_output().empty()) {
@@ skipping 120 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions