Change GitCL to initialize git executable name on Windows.

third_party/WebKit/Tools/Scripts/webkitpy/common/checkout/git.py

 # Copyright (c) 2009, 2010, 2011 Google Inc. All rights reserved.
 # Copyright (c) 2009 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 
 
 class Git(object):
     # Unless otherwise specified, methods are expected to return paths relative
     # to self.checkout_root.
 
     # Git doesn't appear to document error codes, but seems to return
     # 1 or 128, mostly.
     ERROR_FILE_IS_MISSING = 128
 
-    executable_name = 'git'
-
-    def __init__(self, cwd=None, executive=None, filesystem=None):
+    def __init__(self, cwd=None, executive=None, filesystem=None, platform=None):
         self._executive = executive or Executive()
         self._filesystem = filesystem or FileSystem()
+        self._executable_name = self.find_executable_name(self._executive, platform)
 
         self.cwd = cwd or self._filesystem.abspath(self._filesystem.getcwd())
-        if not Git.in_working_directory(self.cwd, executive=self._executive):
+        if not self.in_working_directory(self.cwd):
             module_directory = self._filesystem.abspath(
                 self._filesystem.dirname(self._filesystem.path_to_module(self.__module__)))
             _log.info('The current directory (%s) is not in a git repo, trying directory %s.',
                       cwd, module_directory)
-            if Git.in_working_directory(module_directory, executive=self._executive):
+            if self.in_working_directory(module_directory):
                 self.cwd = module_directory
             _log.error('Failed to find Git repo for %s or %s', cwd, module_directory)
 
-        self._init_executable_name()
         self.checkout_root = self.find_checkout_root(self.cwd)
 
-    def _init_executable_name(self):
-        """Sets the executable name on Windows.
+    @staticmethod
+    def find_executable_name(executive, platform):
+        """Finds the git executable name which may be different on Windows.
 
         The Win port uses the depot_tools package, which contains a number
         of development tools, including Python and git. Instead of using a
         real git executable, depot_tools indirects via a batch file, called
         "git.bat". This batch file is used because it allows depot_tools to
         auto-update the real git executable, which is contained in a
         subdirectory.
 
         FIXME: This is a hack and should be resolved in a different way if
         possible.
         """
+        if not platform or not platform.is_win():
+            return 'git'
         try:
-            self._executive.run_command(['git', 'help'])
+            executive.run_command(['git', 'help'])
+            return 'git'
         except OSError:
-            try:
-                self._executive.run_command(['git.bat', 'help'])
-                _log.debug('Engaging git.bat Windows hack.')
-                self.executable_name = 'git.bat'
-            except OSError:
-                _log.debug('Failed to engage git.bat Windows hack.')
+            _log.debug('Using "git.bat" as git executable.')
+            return 'git.bat'
 
     def run(self, command_args, cwd=None, stdin=None, decode_output=True, return_exit_code=False):
         """Invokes git with the given args."""
-        full_command_args = [self.executable_name] + command_args
+        full_command_args = [self._executable_name] + command_args
         cwd = cwd or self.checkout_root
         return self._executive.run_command(
             full_command_args,
             cwd=cwd,
             input=stdin,
             return_exit_code=return_exit_code,
             decode_output=decode_output)
 
     def absolute_path(self, repository_relative_path):
         """Converts repository-relative paths to absolute paths."""
         return self._filesystem.join(self.checkout_root, repository_relative_path)
 
-    @classmethod
-    def in_working_directory(cls, path, executive=None):
+    def in_working_directory(self, path):
         try:
-            executive = executive or Executive()
-            return executive.run_command(
-                [cls.executable_name, 'rev-parse', '--is-inside-work-tree'],
+            self._executive.run_command(
+                [self._executable_name, 'rev-parse', '--is-inside-work-tree'],
                 cwd=path, error_handler=Executive.ignore_error).rstrip() == 'true'
         except OSError:
             # The Windows bots seem to throw a WindowsError when git isn't installed.
-            # TODO(qyearsley): This might be because the git executable name
-            # isn't initialized yet; maybe this would be fixed by using the
-            # _init_executable_name hack above.
+            # TODO(qyearsley): Check if this is still necessary and remove if possible.
             _log.warn('Got OSError when running Git.in_working_directory.')
             return False
 
     def find_checkout_root(self, path):
         # "git rev-parse --show-cdup" would be another way to get to the root
         checkout_root = self.run(['rev-parse', '--show-toplevel'], cwd=(path or './')).strip()
         if not self._filesystem.isabs(checkout_root):  # Sometimes git returns relative paths
             checkout_root = self._filesystem.join(path, checkout_root)
         return checkout_root
 
@@ skipping 268 matching lines @@
         match = re.search(r"^\s*(?P<branch_name>\S+)\s+merges with remote master$", origin_info, re.MULTILINE)
         if not match:
             raise ScriptError(message='Unable to find local branch tracking origin/master.')
         branch = str(match.group('branch_name'))
         return self._branch_from_ref(self.run(['rev-parse', '--symbolic-full-name', branch]).strip())
 
     def ensure_cleanly_tracking_remote_master(self):
         self._discard_working_directory_changes()
         self.run(['checkout', '-q', self._branch_tracking_remote_master()])
         self._discard_local_commits()