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

tools/gn/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/target.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
@@ skipping 120 matching lines @@
     case LOADABLE_MODULE:
       return "Loadable module";
     case SHARED_LIBRARY:
       return "Shared library";
     case STATIC_LIBRARY:
       return "Static library";
     case SOURCE_SET:
       return "Source set";
     case COPY_FILES:
       return "Copy";
+    case COPY_BUNDLE_DATA:
+      return "Copy bundle data";
     case ACTION:
       return "Action";
     case ACTION_FOREACH:
       return "ActionForEach";
     default:
       return "";
   }
 }
 
 Target* Target::AsTarget() {
@@ skipping 37 matching lines @@
   // This needs to happen after we pull dependent target configs for the
   // public config's libs to be included here. And it needs to happen
   // before pulling the dependent target libs so the libs are in the correct
   // order (local ones first, then the dependency's).
   for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
     const ConfigValues& cur = iter.cur();
     all_lib_dirs_.append(cur.lib_dirs().begin(), cur.lib_dirs().end());
     all_libs_.append(cur.libs().begin(), cur.libs().end());
   }
 
+  PullRecursiveBundleData();
   PullDependentTargetLibs();
   PullRecursiveHardDeps();
   if (!ResolvePrecompiledHeaders(err))
     return false;
 
   FillOutputFiles();
 
   if (settings()->build_settings()->check_for_bad_items()) {
     if (!CheckVisibility(err))
       return false;
@@ skipping 11 matching lines @@
   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 }
 
 bool Target::IsFinal() const {
   return output_type_ == EXECUTABLE ||
          output_type_ == SHARED_LIBRARY ||
          output_type_ == LOADABLE_MODULE ||
          output_type_ == ACTION ||
          output_type_ == ACTION_FOREACH ||
          output_type_ == COPY_FILES ||
+         output_type_ == COPY_BUNDLE_DATA ||
          (output_type_ == STATIC_LIBRARY && complete_static_lib_);
 }
 
 DepsIteratorRange Target::GetDeps(DepsIterationType type) const {
   if (type == DEPS_LINKED) {
     return DepsIteratorRange(DepsIterator(
         &public_deps_, &private_deps_, nullptr));
   }
   // All deps.
   return DepsIteratorRange(DepsIterator(
@@ skipping 110 matching lines @@
     // Direct hard dependencies.
     if (pair.ptr->hard_dep())
       recursive_hard_deps_.insert(pair.ptr);
 
     // Recursive hard dependencies of all dependencies.
     recursive_hard_deps_.insert(pair.ptr->recursive_hard_deps().begin(),
                                 pair.ptr->recursive_hard_deps().end());
   }
 }
 
+void Target::PullRecursiveBundleData() {
+  for (const auto& pair : GetDeps(DEPS_LINKED)) {
+    if (pair.ptr->output_type() == EXECUTABLE ||
+        pair.ptr->output_type() == SHARED_LIBRARY ||
+        pair.ptr->output_type() == LOADABLE_MODULE ||
+        pair.ptr->output_type() == COPY_BUNDLE_DATA)
+      continue;
+
+    bundle_data_.insert(pair.ptr->bundle_data().begin(),
+                        pair.ptr->bundle_data().end());
+  }
+
+  if (output_type_ != COPY_BUNDLE_DATA)
+    return;
+
+  // TODO(sdefresne): .xcasset needs to have a specific treatment. This will
+  // requires a second target using the "bundle_data" information, and for a
+  // way to filter out .xcasset from "copy_bundle_data".
+  sources_.insert(sources_.end(), bundle_data_.begin(), bundle_data_.end());
+}
+
 void Target::FillOutputFiles() {
   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
   bool check_tool_outputs = false;
   switch (output_type_) {
     case GROUP:
     case SOURCE_SET:
     case COPY_FILES:
+    case COPY_BUNDLE_DATA:
     case ACTION:
     case ACTION_FOREACH: {
       // These don't get linked to and use stamps which should be the first
       // entry in the outputs. These stamps are named
       // "<target_out_dir>/<targetname>.stamp".
       dependency_output_file_ = GetTargetOutputDirAsOutputFile(this);
       dependency_output_file_.value().append(GetComputedOutputName(true));
       dependency_output_file_.value().append(".stamp");
       break;
     }
@@ skipping 188 matching lines @@
     return;  // Not in output dir, this is OK.
 
   // Tell the scheduler about unknown files. This will be noted for later so
   // the list of files written by the GN build itself (often response files)
   // can be filtered out of this list.
   OutputFile out_file(settings()->build_settings(), source);
   std::set<const Target*> seen_targets;
   if (!EnsureFileIsGeneratedByDependency(this, out_file, true, &seen_targets))
     g_scheduler->AddUnknownGeneratedInput(this, source);
 }