GN: Move towards only using / on Windows

tools/gn/function_rebase_path.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/build_settings.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/value.h"
 
 namespace functions {
 
 namespace {
 
-enum SeparatorConversion {
-  SEP_TO_SLASH,  // All slashes to forward.
-  SEP_TO_SYSTEM,  // Slashes to system ones.
-};
-
-// Does the specified path separator conversion in-place.
-void ConvertSlashes(std::string* str, SeparatorConversion mode) {
-#if defined(OS_WIN)
-  if (mode == SEP_TO_SYSTEM)
-    std::replace(str->begin(), str->end(), '/', '\\');
-  else
-#endif
-  if (mode == SEP_TO_SLASH)
-    std::replace(str->begin(), str->end(), '\\', '/');
-}
-
 // We want the output to match the input in terms of ending in a slash or not.
 // Through all the transformations, these can get added or removed in various
 // cases.
 void MakeSlashEndingMatchInput(const std::string& input, std::string* output) {
   if (EndsWithSlash(input)) {
     if (!EndsWithSlash(*output))  // Preserve same slash type as input.
       output->push_back(input[input.size() - 1]);
   } else {
     if (EndsWithSlash(*output))
       output->resize(output->size() - 1);
@@ skipping 21 matching lines @@
   // Anything else.
   return false;
 }
 
 Value ConvertOnePath(const Scope* scope,
                      const FunctionCallNode* function,
                      const Value& value,
                      const SourceDir& from_dir,
                      const SourceDir& to_dir,
                      bool convert_to_system_absolute,
-                     SeparatorConversion separator_conversion,
                      Err* err) {
   Value result;  // Ensure return value optimization.
 
   if (!value.VerifyTypeIs(Value::STRING, err))
     return result;
   const std::string& string_value = value.string_value();
 
   bool looks_like_dir = ValueLooksLikeDir(string_value);
 
   // System-absolute output special case.
   if (convert_to_system_absolute) {
     base::FilePath system_path;
     if (looks_like_dir) {
       system_path = scope->settings()->build_settings()->GetFullPath(
           from_dir.ResolveRelativeDir(string_value));
     } else {
       system_path = scope->settings()->build_settings()->GetFullPath(
           from_dir.ResolveRelativeFile(string_value));
     }
     result = Value(function, FilePathToUTF8(system_path));
     if (looks_like_dir)
       MakeSlashEndingMatchInput(string_value, &result.string_value());
-    ConvertPathToSystem(&result.string_value());
     return result;
   }
 
   if (from_dir.is_system_absolute() || to_dir.is_system_absolute()) {
     *err = Err(function, "System-absolute directories are not supported for "
         "the source or dest dir for rebase_path. It would be nice to add this "
         "if you're so inclined!");
     return result;
   }
 
   result = Value(function, Value::STRING);
   if (looks_like_dir) {
     result.string_value() = RebaseSourceAbsolutePath(
         from_dir.ResolveRelativeDir(string_value).value(),
         to_dir);
     MakeSlashEndingMatchInput(string_value, &result.string_value());
   } else {
     result.string_value() = RebaseSourceAbsolutePath(
         from_dir.ResolveRelativeFile(string_value).value(),
         to_dir);
   }
 
-  ConvertSlashes(&result.string_value(), separator_conversion);
   return result;
 }
 
 }  // namespace
 
 const char kRebasePath[] = "rebase_path";
 const char kRebasePath_HelpShort[] =
     "rebase_path: Rebase a file or directory to another location.";
 const char kRebasePath_Help[] =
     "rebase_path: Rebase a file or directory to another location.\n"
     "\n"
     "  converted = rebase_path(input,\n"
     "                          new_base = \"\",\n"
-    "                          current_base = \".\",\n"
-    "                          path_separators = \"to_slash\")\n"
+    "                          current_base = \".\")\n"
     "\n"
     "  Takes a string argument representing a file name, or a list of such\n"
     "  strings and converts it/them to be relative to a different base\n"
     "  directory.\n"
     "\n"
     "  When invoking the compiler or scripts, GN will automatically convert\n"
     "  sources and include directories to be relative to the build directory.\n"
     "  However, if you're passing files directly in the \"args\" array or\n"
     "  doing other manual manipulations where GN doesn't know something is\n"
     "  a file name, you will need to convert paths to be relative to what\n"
@@ skipping 20 matching lines @@
     "      all paths will be converted to system-absolute native style paths\n"
     "      with system path separators. This is useful for invoking external\n"
     "      programs.\n"
     "\n"
     "  current_base\n"
     "      Directory representing the base for relative paths in the input.\n"
     "      If this is not an absolute path, it will be treated as being\n"
     "      relative to the current build file. Use \".\" (the default) to\n"
     "      convert paths from the current BUILD-file's directory.\n"
     "\n"
-    "  path_separators\n"
-    "      On Windows systems, indicates whether and how path separators\n"
-    "      should be converted as part of the transformation. It can be one\n"
-    "      of the following strings:\n"
-    "       - \"to_slash\" Normalize all types of slashes to forward slashes.\n"
-    "         This is the default if this argument is unspecified.\n"
-    "       - \"to_system\" Convert to the system path separators\n"
-    "         (backslashes on Windows).\n"
-    "\n"
     "      On Posix systems there are no path separator transformations\n"
     "      applied. If the new_base is empty (specifying absolute output)\n"
     "      this parameter should not be supplied since paths will always be\n"
     "      converted,\n"
     "\n"
     "Return value\n"
     "\n"
     "  The return value will be the same type as the input value (either a\n"
     "  string or a list of strings). All relative and source-absolute file\n"
     "  names will be converted to be relative to the requested output\n"
@@ skipping 35 matching lines @@
 Value RunRebasePath(Scope* scope,
                     const FunctionCallNode* function,
                     const std::vector<Value>& args,
                     Err* err) {
   Value result;
 
   // Argument indices.
   static const size_t kArgIndexInputs = 0;
   static const size_t kArgIndexDest = 1;
   static const size_t kArgIndexFrom = 2;
-  static const size_t kArgIndexPathConversion = 3;
 
   // Inputs.
-  if (args.size() < 1 || args.size() > 4) {
+  if (args.size() < 1 || args.size() > 3) {
     *err = Err(function->function(), "Wrong # of arguments for rebase_path.");
     return result;
   }
   const Value& inputs = args[kArgIndexInputs];
 
   // To path.
   bool convert_to_system_absolute = true;
   SourceDir to_dir;
   const SourceDir& current_dir = scope->GetSourceDir();
   if (args.size() > kArgIndexDest) {
@@ skipping 12 matching lines @@
     if (!args[kArgIndexFrom].VerifyTypeIs(Value::STRING, err))
       return result;
     from_dir =
         current_dir.ResolveRelativeDir(args[kArgIndexFrom].string_value());
   } else {
     // Default to current directory if unspecified.
     from_dir = current_dir;
   }
 
   // Path conversion.
-  SeparatorConversion sep_conversion = SEP_TO_SLASH;
-  if (args.size() > kArgIndexPathConversion) {
-    if (convert_to_system_absolute) {
-      *err = Err(function, "Can't specify slash conversion.",
-          "You specified absolute system path output by using an empty string "
-          "for the destination directory on rebase_path(). In this case, you "
-          "can't specify slash conversion.");
-      return result;
-    }
-
-    if (!args[kArgIndexPathConversion].VerifyTypeIs(Value::STRING, err))
-      return result;
-    const std::string& sep_string =
-        args[kArgIndexPathConversion].string_value();
-    if (sep_string == "to_slash") {
-      sep_conversion = SEP_TO_SLASH;
-    } else if (sep_string == "to_system") {
-      sep_conversion = SEP_TO_SYSTEM;
-    } else {
-      *err = Err(args[kArgIndexPathConversion],
-          "Invalid path separator conversion mode.",
-          "I was expecting \"to_slash\" or \"to_system\" and\n"
-          "you gave me \"" + args[kArgIndexPathConversion].string_value() +
-          "\".");
-      return result;
-    }
-  }
-
   if (inputs.type() == Value::STRING) {
     return ConvertOnePath(scope, function, inputs,
-                          from_dir, to_dir, convert_to_system_absolute,
-                          sep_conversion, err);
+                          from_dir, to_dir, convert_to_system_absolute, err);
 
   } else if (inputs.type() == Value::LIST) {
     result = Value(function, Value::LIST);
     result.list_value().reserve(inputs.list_value().size());
 
     for (size_t i = 0; i < inputs.list_value().size(); i++) {
       result.list_value().push_back(
           ConvertOnePath(scope, function, inputs.list_value()[i],
-                         from_dir, to_dir, convert_to_system_absolute,
-                         sep_conversion, err));
+                         from_dir, to_dir, convert_to_system_absolute, err));
       if (err->has_error()) {
         result = Value();
         return result;
       }
     }
     return result;
   }
 
   *err = Err(function->function(),
              "rebase_path requires a list or a string.");
   return result;
 }
 
 }  // namespace functions