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

tools/gn/ninja_create_bundle_target_writer.cc

Index: tools/gn/ninja_create_bundle_target_writer.cc
diff --git a/tools/gn/ninja_create_bundle_target_writer.cc b/tools/gn/ninja_create_bundle_target_writer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0b9f90a298c627c656010ab822cbe835a5dfd4f1
--- /dev/null
+++ b/tools/gn/ninja_create_bundle_target_writer.cc
@@ -0,0 +1,116 @@
+// Copyright 2016 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/ninja_create_bundle_target_writer.h"
+
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/ninja_utils.h"
+#include "tools/gn/output_file.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/substitution_writer.h"
+#include "tools/gn/target.h"
+#include "tools/gn/toolchain.h"
+
+namespace {
+
+void FailWithMissingToolError(Toolchain::ToolType tool,
+                              const Target* target) {
+  const std::string& tool_name = Toolchain::ToolTypeToName(tool);
+  g_scheduler->FailWithError(Err(
+      nullptr, tool_name + " tool not defined",
+      "The toolchain " +
+          target->toolchain()->label().GetUserVisibleName(false) + "\n"
+          "used by target " + target->label().GetUserVisibleName(false) + "\n"
+          "doesn't define a \"" + tool_name + "\" tool."));
+}
+
+}  // namespace
+
+NinjaCreateBundleTargetWriter::NinjaCreateBundleTargetWriter(
+    const Target* target,
+    std::ostream& out)
+    : NinjaTargetWriter(target, out) {}
+
+NinjaCreateBundleTargetWriter::~NinjaCreateBundleTargetWriter() {}
+
+void NinjaCreateBundleTargetWriter::Run() {
+  if (!target_->toolchain()->GetTool(Toolchain::TYPE_COPY_BUNDLE_DATA)) {

[brettw, 2016/03/02 21:12:42]

We should have a unit test file for this like we do for the other writer files.

[sdefresne, 2016/03/07 20:47:35]

Done.

+    FailWithMissingToolError(Toolchain::TYPE_COPY_BUNDLE_DATA, target_);
+    return;
+  }
+
+  if (!target_->toolchain()->GetTool(Toolchain::TYPE_COMPILE_XCASSETS)) {
+    FailWithMissingToolError(Toolchain::TYPE_COMPILE_XCASSETS, target_);
+    return;
+  }
+
+  if (!target_->toolchain()->GetTool(Toolchain::TYPE_STAMP)) {
+    FailWithMissingToolError(Toolchain::TYPE_STAMP, target_);
+    return;
+  }
+
+  std::vector<OutputFile> output_files;
+  OutputFile input_dep =
+      WriteInputDepsStampAndGetDep(std::vector<const Target*>());
+
+  for (const BundleFileRule& file_rule : target_->bundle_data().file_rules()) {
+    for (const SourceFile& source_file : file_rule.sources()) {
+      OutputFile output_file = file_rule.ApplyPatternToSourceAsOutputFile(
+          settings_, target_->bundle_data(), source_file);
+      output_files.push_back(output_file);
+
+      out_ << "build ";
+      path_output_.WriteFile(out_, output_file);
+      out_ << ": "
+           << GetNinjaRulePrefixForToolchain(settings_)
+           << Toolchain::ToolTypeToName(Toolchain::TYPE_COPY_BUNDLE_DATA)
+           << " ";
+      path_output_.WriteFile(out_, source_file);
+      if (!input_dep.value().empty()) {
+        out_ << " || ";
+        path_output_.WriteFile(out_, input_dep);
+      }
+      out_ << std::endl;
+    }
+  }
+
+  if (!target_->bundle_data().asset_catalog_sources().empty()) {
+    OutputFile output_file(
+        settings_->build_settings(),
+        target_->bundle_data().GetCompiledAssetCatalogPath());
+    output_files.push_back(output_file);
+
+    out_ << "build ";
+    path_output_.WriteFile(out_, output_file);
+    out_ << ": "
+         << GetNinjaRulePrefixForToolchain(settings_)
+         << Toolchain::ToolTypeToName(Toolchain::TYPE_COMPILE_XCASSETS);
+
+    std::set<SourceFile> asset_catalog_bundles;
+    for (const auto& source : target_->bundle_data().asset_catalog_sources()) {
+      SourceFile asset_catalog_bundle;
+      CHECK(IsSourceFileFromAssetCatalog(source, &asset_catalog_bundle));
+      if (asset_catalog_bundles.find(asset_catalog_bundle) !=
+          asset_catalog_bundles.end())
+        continue;
+      out_ << " ";
+      path_output_.WriteFile(out_, asset_catalog_bundle);
+      asset_catalog_bundles.insert(asset_catalog_bundle);
+    }
+
+    out_ << " |";
+    for (const auto& source : target_->bundle_data().asset_catalog_sources()) {
+      out_ << " ";
+      path_output_.WriteFile(out_, source);
+    }
+    if (!input_dep.value().empty()) {
+      out_ << " || ";
+      path_output_.WriteFile(out_, input_dep);
+    }
+    out_ << std::endl;
+  }
+
+  out_ << std::endl;
+  WriteStampForTarget(output_files, std::vector<OutputFile>());
+}