Let third_party/crashpad/update.py work on Windows

third_party/crashpad/update.py

 #!/usr/bin/env python
 # coding: utf-8
 
 # Copyright 2015 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.
 
 import argparse
 import os
 import re
 import subprocess
 import sys
 import textwrap
 
 
+IS_WINDOWS = sys.platform.startswith('win')
+
+
 def SubprocessCheckCall0Or1(args):
     """Like subprocss.check_call(), but allows a return code of 1.
 
     Returns True if the subprocess exits with code 0, False if it exits with
     code 1, and re-raises the subprocess.check_call() exception otherwise.
     """
     try:
-        subprocess.check_call(args)
+        subprocess.check_call(args, shell=IS_WINDOWS)
     except subprocess.CalledProcessError, e:
         if e.returncode != 1:
             raise
         return False
 
     return True
 
 
 def GitMergeBaseIsAncestor(ancestor, descendant):
     """Determines whether |ancestor| is an ancestor of |descendant|.
@@ skipping 26 matching lines @@
         help='The remote ref to fetch',
         metavar='REF')
     parser.add_argument(
         '--readme',
         help='The README.chromium file describing the imported project',
         metavar='FILE',
         dest='readme_path')
     parsed = parser.parse_args(args)
 
     original_head = (
-        subprocess.check_output(['git', 'rev-parse', 'HEAD']).rstrip())
+        subprocess.check_output(['git', 'rev-parse', 'HEAD'],
+                                shell=IS_WINDOWS).rstrip())
 
     # Read the README, because that’s what it’s for. Extract some things from
     # it, and save it to be able to update it later.
     readme_path = (parsed.readme_path or
                    os.path.join(os.path.dirname(__file__ or '.'),
                                 'README.chromium'))
     readme_content_old = open(readme_path).read()
 
     project_name_match = re.search(
         r'^Name:\s+(.*)$', readme_content_old, re.MULTILINE)
     project_name = project_name_match.group(1)
 
     # Extract the original commit hash from the README.
     revision_match = re.search(r'^Revision:\s+([0-9a-fA-F]{40})($|\s)',
                                readme_content_old,
                                re.MULTILINE)
     revision_old = revision_match.group(1)
 
-    subprocess.check_call(['git', 'fetch', parsed.repository, parsed.fetch_ref])
+    subprocess.check_call(['git', 'fetch', parsed.repository, parsed.fetch_ref],
+                          shell=IS_WINDOWS)
 
     # Make sure that parsed.update_to is an ancestor of FETCH_HEAD, and
     # revision_old is an ancestor of parsed.update_to. This prevents the use of
     # hashes that are known to git but that don’t make sense in the context of
     # the update operation.
     if not GitMergeBaseIsAncestor(parsed.update_to, 'FETCH_HEAD'):
         raise Exception('update_to is not an ancestor of FETCH_HEAD',
                         parsed.update_to,
                         'FETCH_HEAD')
     if not GitMergeBaseIsAncestor(revision_old, parsed.update_to):
@@ skipping 18 matching lines @@
             print >>sys.stderr, ("""
 Please fix the errors above and run "git cherry-pick --continue".
 Press Enter when "git cherry-pick" completes.
 You may use a new shell for this, or ^Z if job control is available.
 Press ^C to abort.
 """)
             raw_input()
     except:
         # ^C, signal, or something else.
         print >>sys.stderr, 'Aborting...'
-        subprocess.call(['git', 'cherry-pick', '--abort'])
+        subprocess.call(['git', 'cherry-pick', '--abort'], shell=IS_WINDOWS)
         raise
 
     # Get an abbreviated hash and subject line for each commit in the window,
     # sorted in chronological order.
     log_lines = subprocess.check_output(['git',
                                          '-c',
                                          'core.abbrev=12',
                                          'log',
                                          '--abbrev-commit',
                                          '--pretty=oneline',
                                          '--reverse',
-                                         update_range]).splitlines(False)
+                                         update_range],
+                                         shell=IS_WINDOWS).splitlines(False)
 
     if assisted_cherry_pick:
         # If the user had to help, count the number of cherry-picked commits,
         # expecting it to match.
         cherry_picked_commits = int(subprocess.check_output(
             ['git', 'rev-list', '--count', original_head + '..HEAD']))
         if cherry_picked_commits != len(log_lines):
             print >>sys.stderr, 'Something smells fishy, aborting anyway...'
-            subprocess.call(['git', 'cherry-pick', '--abort'])
+            subprocess.call(['git', 'cherry-pick', '--abort'], shell=IS_WINDOWS)
             raise Exception('not all commits were cherry-picked',
                             len(log_lines),
                             cherry_picked_commits)
 
     # Make a nice commit message. Start with the full commit hash.
     revision_new = subprocess.check_output(
-        ['git', 'rev-parse', parsed.update_to]).rstrip()
+        ['git', 'rev-parse', parsed.update_to], shell=IS_WINDOWS).rstrip()
     new_message = 'Update ' + project_name + ' to ' + revision_new + '\n\n'
 
     # Wrap everything to 72 characters, with a hanging indent.
     wrapper = textwrap.TextWrapper(width=72, subsequent_indent = ' ' * 13)
     for line in log_lines:
         # Strip trailing periods from subjects.
         if line.endswith('.'):
             line = line[:-1]
 
         # If any subjects have what look like commit hashes in them, truncate
@@ skipping 23 matching lines @@
         has_local_modifications = False
 
         readme_content_new = re.sub(r'\nLocal Modifications:\n.*$',
                                     '\nLocal Modifications:\nNone.',
                                     readme_content_new,
                                     1)
 
     # This soft-reset causes all of the cherry-picks to show up as staged,
     # which will have the effect of squashing them along with the README update
     # when committed below.
-    subprocess.check_call(['git', 'reset', '--soft', original_head])
+    subprocess.check_call(['git', 'reset', '--soft', original_head],
+                          shell=IS_WINDOWS)
 
     # Write the new README.
     open(readme_path, 'wb').write(readme_content_new)
 
     # Commit everything.
-    subprocess.check_call(['git', 'add', readme_path])
-    subprocess.check_call(['git', 'commit', '--message=' + new_message])
+    subprocess.check_call(['git', 'add', readme_path], shell=IS_WINDOWS)
+    subprocess.check_call(['git', 'commit', '--message=' + new_message],
+                          shell=IS_WINDOWS)
 
     if has_local_modifications:
         print >>sys.stderr, (
             'Remember to check the Local Modifications section in ' +
             readme_path)
 
     return 0
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv[1:]))