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

tools/gn/target_generator.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_generator.h"
 
 #include <stddef.h>
 
 #include "tools/gn/action_target_generator.h"
 #include "tools/gn/binary_target_generator.h"
@@ skipping 26 matching lines @@
 }
 
 void TargetGenerator::Run() {
   // All target types use these.
   if (!FillDependentConfigs())
     return;
 
   if (!FillData())
     return;
 
+  if (!FillBundleData())
+    return;
+
   if (!FillDependencies())
     return;
 
   if (!FillTestonly())
     return;
 
   if (!FillAssertNoDeps())
     return;
 
   if (!Visibility::FillItemVisibility(target_, scope_, err_))
@@ skipping 23 matching lines @@
   Label label(scope->GetSourceDir(), args[0].string_value(),
               toolchain_label.dir(), toolchain_label.name());
 
   if (g_scheduler->verbose_logging())
     g_scheduler->Log("Defining target", label.GetUserVisibleName(true));
 
   scoped_ptr<Target> target(new Target(scope->settings(), label));
   target->set_defined_from(function_call);
 
   // Create and call out to the proper generator.
-  if (output_type == functions::kCopy) {
-    CopyTargetGenerator generator(target.get(), scope, function_call, err);
+  if (output_type == functions::kCopy ||
+      output_type == functions::kCopyBundleData) {
+    Target::OutputType target_output_type = output_type == functions::kCopy
+                                                ? Target::COPY_FILES
+                                                : Target::COPY_BUNDLE_DATA;
+    CopyTargetGenerator generator(target.get(), scope, function_call,
+                                  target_output_type, err);
     generator.Run();
   } else if (output_type == functions::kAction) {
     ActionTargetGenerator generator(target.get(), scope, function_call,
                                     Target::ACTION, err);
     generator.Run();
   } else if (output_type == functions::kActionForEach) {
     ActionTargetGenerator generator(target.get(), scope, function_call,
                                     Target::ACTION_FOREACH, err);
     generator.Run();
   } else if (output_type == functions::kExecutable) {
@@ skipping 132 matching lines @@
       // Resolve as file.
       SourceFile resolved = dir.ResolveRelativeFile(input, err_, root_path);
       if (err_->has_error())
         return false;
       output_list.push_back(resolved.value());
     }
   }
   return true;
 }
 
+bool TargetGenerator::FillBundleData() {
+  const Value* value = scope_->GetValue(variables::kBundleData, true);
+  if (!value)
+    return true;
+
+  Target::FileList bundle_data;
+  if (!ExtractListOfRelativeFiles(scope_->settings()->build_settings(), *value,
+                                  scope_->GetSourceDir(), &bundle_data, err_))
+    return false;
+
+  target_->bundle_data().insert(bundle_data.begin(), bundle_data.end());
+  return true;
+}
+
+bool TargetGenerator::FillBundleDataFilter() {
+  const Value* value = scope_->GetValue(variables::kBundleDataFilter, true);
+  if (!value)
+    return true;
+
+  PatternList filter;
+  filter.SetFromValue(*value, err_);
+  if (err_->has_error())
+    return false;
+
+  std::swap(target_->bundle_data_filter(), filter);
+  return true;
+}
+
 bool TargetGenerator::FillDependencies() {
   if (!FillGenericDeps(variables::kDeps, &target_->private_deps()))
     return false;
   if (!FillGenericDeps(variables::kPublicDeps, &target_->public_deps()))
     return false;
   if (!FillGenericDeps(variables::kDataDeps, &target_->data_deps()))
     return false;
 
   // "data_deps" was previously named "datadeps". For backwards-compat, read
   // the old one if no "data_deps" were specified.
@@ skipping 112 matching lines @@
 
 bool TargetGenerator::FillGenericDeps(const char* var_name,
                                       LabelTargetVector* dest) {
   const Value* value = scope_->GetValue(var_name, true);
   if (value) {
     ExtractListOfLabels(*value, scope_->GetSourceDir(),
                         ToolchainLabelForScope(scope_), dest, err_);
   }
   return !err_->has_error();
 }