Allow python.bat files for finding Python in GN.

tools/gn/setup.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/setup.h"
 
 #include <stdlib.h>
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/process/launch.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/standard_out.h"
@@ skipping 113 matching lines @@
   DCHECK(item);
   main_loop->PostTask(FROM_HERE, base::Bind(&Builder::ItemDefined, builder,
                                             base::Passed(&item)));
 }
 
 void DecrementWorkCount() {
   g_scheduler->DecrementWorkCount();
 }
 
 #if defined(OS_WIN)
+
+// Given the path to a batch file that runs Python, extracts the name of the
+// executable actually implementing Python. Generally people write a batch file
+// to put something named "python" on the path, which then just redirects to
+// a python.exe somewhere else. This step decodes that setup. On failure,
+// returns empty path.
+base::FilePath PythonBatToExe(const base::FilePath& bat_path) {
+  // Note exciting double-quoting to allow spaces. The /c switch seems to check
+  // for quotes around the whole thing and then deletes them. If you want to
+  // quote the first argument in addition (to allow for spaces in the Python
+  // path, you need *another* set of quotes around that, likewise, we need
+  // two quotes at the end.
+  base::string16 command = L"cmd.exe /c \"\"";
+  command.append(bat_path.value());
+  command.append(L"\" -c \"import sys; print sys.executable\"\"");
+
+  std::string python_path;
+  if (base::GetAppOutput(command, &python_path)) {
+    base::TrimWhitespaceASCII(python_path, base::TRIM_ALL, &python_path);
+
+    // Python uses the system multibyte code page for sys.executable.
+    base::FilePath exe_path(base::SysNativeMBToWide(python_path));
+
+    // Check for reasonable output, cmd may have output an error message.
+    if (base::PathExists(exe_path))
+      return exe_path;
+  }
+  return base::FilePath();
+}
+
 const base::char16 kPythonExeName[] = L"python.exe";
+const base::char16 kPythonBatName[] = L"python.bat";
 
 base::FilePath FindWindowsPython() {
   base::char16 current_directory[MAX_PATH];
   ::GetCurrentDirectory(MAX_PATH, current_directory);
 
   // First search for python.exe in the current directory.
   base::FilePath cur_dir_candidate_exe =
       base::FilePath(current_directory).Append(kPythonExeName);
   if (base::PathExists(cur_dir_candidate_exe))
     return cur_dir_candidate_exe;
 
   // Get the path.
   const base::char16 kPathEnvVarName[] = L"Path";
   DWORD path_length = ::GetEnvironmentVariable(kPathEnvVarName, nullptr, 0);
   if (path_length == 0)
     return base::FilePath();
   scoped_ptr<base::char16[]> full_path(new base::char16[path_length]);
   DWORD actual_path_length =
       ::GetEnvironmentVariable(kPathEnvVarName, full_path.get(), path_length);
   CHECK_EQ(path_length, actual_path_length + 1);
 
   // Search for python.exe in the path.
   for (const auto& component : base::SplitStringPiece(
            base::StringPiece16(full_path.get(), path_length), L";",
            base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
     base::FilePath candidate_exe =
         base::FilePath(component).Append(kPythonExeName);
     if (base::PathExists(candidate_exe))
       return candidate_exe;
+
+    // Also allow python.bat, but convert into the .exe.
+    base::FilePath candidate_bat =
+        base::FilePath(component).Append(kPythonBatName);
+    if (base::PathExists(candidate_bat)) {
+      base::FilePath python_exe = PythonBatToExe(candidate_bat);
+      if (!python_exe.empty())
+        return python_exe;
+    }
   }
   return base::FilePath();
 }
 #endif
 
 }  // namespace
 
 const char Setup::kBuildArgFileName[] = "args.gn";
 
 Setup::Setup()
@@ skipping 458 matching lines @@
       if (err.has_error()) {
         err.PrintToStdout();
         return false;
       }
     }
     build_settings_.set_exec_script_whitelist(std::move(whitelist));
   }
 
   return true;
 }