[GN] Allow spaces in output names and other substitutions.

tools/gn/ninja_target_writer.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/ninja_target_writer.h"
 
 #include <sstream>
 
 #include "base/files/file_util.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/err.h"
+#include "tools/gn/escape.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/ninja_action_target_writer.h"
 #include "tools/gn/ninja_binary_target_writer.h"
 #include "tools/gn/ninja_copy_target_writer.h"
 #include "tools/gn/ninja_group_target_writer.h"
 #include "tools/gn/ninja_utils.h"
 #include "tools/gn/output_file.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/string_utils.h"
-#include "tools/gn/substitution_type.h"
 #include "tools/gn/substitution_writer.h"
 #include "tools/gn/target.h"
 #include "tools/gn/trace.h"
 
 NinjaTargetWriter::NinjaTargetWriter(const Target* target,
                                      std::ostream& out)
     : settings_(target->settings()),
       target_(target),
       out_(out),
       path_output_(settings_->build_settings()->build_dir(),
@@ skipping 13 matching lines @@
   trace.SetToolchain(settings->toolchain_label());
 
   base::FilePath ninja_file(settings->build_settings()->GetFullPath(
       GetNinjaFileForTarget(target)));
 
   if (g_scheduler->verbose_logging())
     g_scheduler->Log("Writing", FilePathToUTF8(ninja_file));
 
   base::CreateDirectory(ninja_file.DirName());
 
-  // It's rediculously faster to write to a string and then write that to
+  // It's ridiculously faster to write to a string and then write that to
   // disk in one operation than to use an fstream here.
   std::stringstream file;
 
   // Call out to the correct sub-type of writer.
   if (target->output_type() == Target::COPY_FILES) {
     NinjaCopyTargetWriter writer(target, file);
     writer.Run();
   } else if (target->output_type() == Target::ACTION ||
              target->output_type() == Target::ACTION_FOREACH) {
     NinjaActionTargetWriter writer(target, file);
@@ skipping 10 matching lines @@
     writer.Run();
   } else {
     CHECK(0) << "Output type of target not handled.";
   }
 
   std::string contents = file.str();
   base::WriteFile(ninja_file, contents.c_str(),
                   static_cast<int>(contents.size()));
 }
 
+void NinjaTargetWriter::WriteEscapedSubstitution(SubstitutionType type) {
+  EscapeOptions opts;
+  opts.mode = ESCAPE_NINJA;
+
+  out_ << kSubstitutionNinjaNames[type] << " = ";
+  EscapeStringToStream(out_,
+      SubstitutionWriter::GetTargetSubstitution(target_, type),
+      opts);
+  out_ << std::endl;
+}
+
 void NinjaTargetWriter::WriteSharedVars(const SubstitutionBits& bits) {
   bool written_anything = false;
 
   // Target label.
   if (bits.used[SUBSTITUTION_LABEL]) {
-    out_ << kSubstitutionNinjaNames[SUBSTITUTION_LABEL] << " = "
-         << SubstitutionWriter::GetTargetSubstitution(
-                target_, SUBSTITUTION_LABEL)
-         << std::endl;
+    WriteEscapedSubstitution(SUBSTITUTION_LABEL);
     written_anything = true;
   }
 
   // Root gen dir.
   if (bits.used[SUBSTITUTION_ROOT_GEN_DIR]) {
-    out_ << kSubstitutionNinjaNames[SUBSTITUTION_ROOT_GEN_DIR] << " = "
-         << SubstitutionWriter::GetTargetSubstitution(
-                target_, SUBSTITUTION_ROOT_GEN_DIR)
-         << std::endl;
+    WriteEscapedSubstitution(SUBSTITUTION_ROOT_GEN_DIR);
     written_anything = true;
   }
 
   // Root out dir.
   if (bits.used[SUBSTITUTION_ROOT_OUT_DIR]) {
-    out_ << kSubstitutionNinjaNames[SUBSTITUTION_ROOT_OUT_DIR] << " = "
-         << SubstitutionWriter::GetTargetSubstitution(
-                target_, SUBSTITUTION_ROOT_OUT_DIR)
-         << std::endl;
+    WriteEscapedSubstitution(SUBSTITUTION_ROOT_OUT_DIR);
     written_anything = true;
   }
 
   // Target gen dir.
   if (bits.used[SUBSTITUTION_TARGET_GEN_DIR]) {
-    out_ << kSubstitutionNinjaNames[SUBSTITUTION_TARGET_GEN_DIR] << " = "
-         << SubstitutionWriter::GetTargetSubstitution(
-                target_, SUBSTITUTION_TARGET_GEN_DIR)
-         << std::endl;
+    WriteEscapedSubstitution(SUBSTITUTION_TARGET_GEN_DIR);
     written_anything = true;
   }
 
   // Target out dir.
   if (bits.used[SUBSTITUTION_TARGET_OUT_DIR]) {
-    out_ << kSubstitutionNinjaNames[SUBSTITUTION_TARGET_OUT_DIR] << " = "
-         << SubstitutionWriter::GetTargetSubstitution(
-                target_, SUBSTITUTION_TARGET_OUT_DIR)
-         << std::endl;
+    WriteEscapedSubstitution(SUBSTITUTION_TARGET_OUT_DIR);
     written_anything = true;
   }
 
   // Target output name.
   if (bits.used[SUBSTITUTION_TARGET_OUTPUT_NAME]) {
-    out_ << kSubstitutionNinjaNames[SUBSTITUTION_TARGET_OUTPUT_NAME] << " = "
-         << SubstitutionWriter::GetTargetSubstitution(
-                target_, SUBSTITUTION_TARGET_OUTPUT_NAME)
-         << std::endl;
+    WriteEscapedSubstitution(SUBSTITUTION_TARGET_OUTPUT_NAME);
     written_anything = true;
   }
 
   // If we wrote any vars, separate them from the rest of the file that follows
   // with a blank line.
   if (written_anything)
     out_ << std::endl;
 }
 
 OutputFile NinjaTargetWriter::WriteInputDepsStampAndGetDep(
@@ skipping 106 matching lines @@
        << GetNinjaRulePrefixForToolchain(settings_)
        << Toolchain::ToolTypeToName(Toolchain::TYPE_STAMP);
   path_output_.WriteFiles(out_, files);
 
   if (!order_only_deps.empty()) {
     out_ << " ||";
     path_output_.WriteFiles(out_, order_only_deps);
   }
   out_ << std::endl;
 }