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

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 <algorithm>
 
@@ skipping 206 matching lines @@
     case SOURCE_SET:
       return "Source set";
     case COPY_FILES:
       return "Copy";
     case ACTION:
       return "Action";
     case ACTION_FOREACH:
       return "ActionForEach";
     case BUNDLE_DATA:
       return "Bundle data";
+    case CREATE_BUNDLE:
+      return "Create bundle";
     default:
       return "";
   }
 }
 
 Target* Target::AsTarget() {
   return this;
 }
 
 const Target* Target::AsTarget() const {
@@ skipping 33 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 21 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_ == CREATE_BUNDLE ||
          (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 138 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() {
+  if (output_type_ != CREATE_BUNDLE)
+    return;
+
+  std::set<const Target*> visited;
+  std::vector<const Target*> deps;
+  deps.push_back(this);
+
+  while (!deps.empty()) {
+    const Target* current = deps.back();
+    deps.pop_back();
+
+    if (visited.find(current) != visited.end())
+      continue;
+    visited.insert(current);
+
+    if (current->output_type_ == BUNDLE_DATA)
+      bundle_data_.AddFileRuleFromTarget(current);
+
+    for (const LabelTargetPair& pair : current->GetDeps(DEPS_ALL)) {
+      DCHECK(pair.ptr);
+      DCHECK(pair.ptr->toolchain_);
+      if (visited.find(pair.ptr) != visited.end())
+        continue;
+
+      if (pair.ptr->output_type() == CREATE_BUNDLE)
+        continue;
+
+      deps.push_back(pair.ptr);
+    }
+  }
+
+  bundle_data_.GetSourceFiles(&sources_);
+}
+
 void Target::FillOutputFiles() {
   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
   bool check_tool_outputs = false;
   switch (output_type_) {
     case GROUP:
     case BUNDLE_DATA:
+    case CREATE_BUNDLE:
     case SOURCE_SET:
     case COPY_FILES:
     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");
@@ skipping 45 matching lines @@
           runtime_link_output_file_ =
               SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
                   this, tool, tool->runtime_link_output());
       }
       break;
     case UNKNOWN:
     default:
       NOTREACHED();
   }
 
+  // Count anything generated from bundle_data dependencies.
+  if (output_type_ == CREATE_BUNDLE)
+    bundle_data_.GetOutputFiles(settings(), &computed_outputs_);
+
   // Count all outputs from this tool as something generated by this target.
   if (check_tool_outputs) {
     SubstitutionWriter::ApplyListToLinkerAsOutputFile(
         this, tool, tool->outputs(), &computed_outputs_);
 
     // Output names aren't canonicalized in the same way that source files
     // are. For example, the tool outputs often use
     // {{some_var}}/{{output_name}} which expands to "./foo", but this won't
     // match "foo" which is what we'll compute when converting a SourceFile to
     // an OutputFile.
@@ skipping 160 matching lines @@
   if (!EnsureFileIsGeneratedByDependency(this, out_file, true, false,
                                          &seen_targets)) {
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
     seen_targets.clear();
     if (!EnsureFileIsGeneratedByDependency(this, out_file, true, true,
                                            &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }