Redo escaping in GN

tools/gn/ninja_binary_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_binary_target_writer.h"
 
 #include <set>
 
 #include "base/strings/string_util.h"
 #include "tools/gn/config_values_extractors.h"
 #include "tools/gn/err.h"
 #include "tools/gn/escape.h"
 #include "tools/gn/string_utils.h"
 
 namespace {
 
 // Returns the proper escape options for writing compiler and linker flags.
 EscapeOptions GetFlagOptions() {
   EscapeOptions opts;
-  opts.mode = ESCAPE_NINJA;
+  opts.mode = ESCAPE_NINJA_COMMAND;
 
   // Some flag strings are actually multiple flags that expect to be just
   // added to the command line. We assume that quoting is done by the
   // buildfiles if it wants such things quoted.
   opts.inhibit_quoting = true;
 
   return opts;
 }
 
 struct DefineWriter {
   DefineWriter() {
-    options.mode = ESCAPE_SHELL;
+    options.mode = ESCAPE_NINJA_COMMAND;
   }
 
   void operator()(const std::string& s, std::ostream& out) const {
     out << " -D";
     EscapeStringToStream(out, s, options);
   }
 
   EscapeOptions options;
 };
 
 struct IncludeWriter {
-  IncludeWriter(PathOutput& path_output,
-                const NinjaHelper& h)
+  IncludeWriter(PathOutput& path_output, const NinjaHelper& h)
       : helper(h),
-        path_output_(path_output),
-        old_inhibit_quoting_(path_output.inhibit_quoting()) {
-    // Inhibit quoting since we'll put quotes around the whole thing ourselves.
-    // Since we're writing in NINJA escaping mode, this won't actually do
-    // anything, but I think we may need to change to shell-and-then-ninja
-    // escaping for this in the future.
-    path_output_.set_inhibit_quoting(true);
+        path_output_(path_output) {
   }
   ~IncludeWriter() {
-    path_output_.set_inhibit_quoting(old_inhibit_quoting_);
   }
 
   void operator()(const SourceDir& d, std::ostream& out) const {
-    out << " \"-I";
-    // It's important not to include the trailing slash on directories or on
-    // Windows it will be a backslash and the compiler might think we're
-    // escaping the quote!
+    out << " -I";
     path_output_.WriteDir(out, d, PathOutput::DIR_NO_LAST_SLASH);
-    out << "\"";
   }
 
   const NinjaHelper& helper;
   PathOutput& path_output_;
-  bool old_inhibit_quoting_;  // So we can put the PathOutput back.
 };
 
 Toolchain::ToolType GetToolTypeForTarget(const Target* target) {
   switch (target->output_type()) {
     case Target::STATIC_LIBRARY:
       return Toolchain::TYPE_ALINK;
     case Target::SHARED_LIBRARY:
       return Toolchain::TYPE_SOLINK;
     case Target::EXECUTABLE:
       return Toolchain::TYPE_LINK;
@@ skipping 180 matching lines @@
   EscapeOptions flag_options = GetFlagOptions();
   RecursiveTargetConfigStringsToStream(target_, &ConfigValues::ldflags,
                                        flag_options, out_);
 
   // Followed by library search paths that have been recursively pushed
   // through the dependency tree.
   const OrderedSet<SourceDir> all_lib_dirs = target_->all_lib_dirs();
   if (!all_lib_dirs.empty()) {
     // Since we're passing these on the command line to the linker and not
     // to Ninja, we need to do shell escaping.
-    PathOutput lib_path_output(
-        path_output_.current_dir(), ESCAPE_NINJA_SHELL, false);
+    PathOutput lib_path_output(path_output_.current_dir(),
+                               ESCAPE_NINJA_COMMAND);
     for (size_t i = 0; i < all_lib_dirs.size(); i++) {
       out_ << " " << tool.lib_dir_prefix;
       lib_path_output.WriteDir(out_, all_lib_dirs[i],
                                PathOutput::DIR_NO_LAST_SLASH);
     }
   }
 
   // Append manifest flag on Windows to reference our file.
   // HACK ERASEME BRETTW FIXME
   if (settings_->IsWin()) {
     out_ << " /MANIFEST /ManifestFile:";
     path_output_.WriteFile(out_, windows_manifest);
   }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteLibs(const Toolchain::Tool& tool) {
   out_ << "libs =";
 
   // Libraries that have been recursively pushed through the dependency tree.
   EscapeOptions lib_escape_opts;
-  lib_escape_opts.mode = ESCAPE_NINJA_SHELL;
+  lib_escape_opts.mode = ESCAPE_NINJA_COMMAND;
   const OrderedSet<std::string> all_libs = target_->all_libs();
   const std::string framework_ending(".framework");
   for (size_t i = 0; i < all_libs.size(); i++) {
     if (settings_->IsMac() && EndsWith(all_libs[i], framework_ending, false)) {
       // Special-case libraries ending in ".framework" on Mac. Add the
       // -framework switch and don't add the extension to the output.
       out_ << " -framework ";
       EscapeStringToStream(out_,
           all_libs[i].substr(0, all_libs[i].size() - framework_ending.size()),
           lib_escape_opts);
@@ skipping 166 matching lines @@
     }
 
     // Data files.
     const std::vector<SourceFile>& data = target_->data();
     for (size_t i = 0; i < data.size(); i++) {
       out_ << " ";
       path_output_.WriteFile(out_, data[i]);
     }
   }
 }