Revert of Bring Syzygy binaries in using a script rather than as a dependency.

build/get_syzygy_binaries.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """A utility script for downloading versioned Syzygy binaries."""
 
 import cStringIO
 import hashlib
-import errno
 import json
 import logging
 import optparse
 import os
 import re
 import shutil
-import stat
-import sys
 import subprocess
 import urllib2
 import zipfile
 
 
 _LOGGER = logging.getLogger(os.path.basename(__file__))
 
 # The URL where official builds are archived.
 _SYZYGY_ARCHIVE_URL = ('http://syzygy-archive.commondatastorage.googleapis.com/'
     'builds/official/%(revision)s')
@@ skipping 139 matching lines @@
     return (stored, False)
   return (stored, True)
 
 
 def _DirIsEmpty(path):
   """Returns true if the given directory is empty, false otherwise."""
   for root, dirs, files in os.walk(path):
     return not dirs and not files
 
 
-def _RmTreeHandleReadOnly(func, path, exc):
-  """An error handling function for use with shutil.rmtree. This will
-  detect failures to remove read-only files, and will change their properties
-  prior to removing them. This is necessary on Windows as os.remove will return
-  an access error for read-only files, and git repos contain read-only
-  pack/index files.
-  """
-  excvalue = exc[1]
-  if func in (os.rmdir, os.remove) and excvalue.errno == errno.EACCES:
-    _LOGGER.debug('Removing read-only path: %s', path)
-    os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
-    func(path)
-  else:
-    raise
-
-
-def _RmTree(path):
-  """A wrapper of shutil.rmtree that handles read-only files."""
-  shutil.rmtree(path, ignore_errors=False, onerror=_RmTreeHandleReadOnly)
-
-
 def _CleanState(output_dir, state, dry_run=False):
   """Cleans up files/directories in |output_dir| that are referenced by
   the given |state|. Raises an error if there are local changes. Returns a
   dictionary of files that were deleted.
   """
   _LOGGER.debug('Deleting files from previous installation.')
   deleted = {}
 
   # Generate a list of files to delete, relative to |output_dir|.
   contents = state['contents']
@@ skipping 24 matching lines @@
       if not dry_run:
         os.unlink(fullpath)
 
   # Sort directories from longest name to shortest. This lets us remove empty
   # directories from the most nested paths first.
   dirs = sorted(dirs.keys(), key=lambda x: len(x), reverse=True)
   for p in dirs:
     if os.path.exists(p) and _DirIsEmpty(p):
       _LOGGER.debug('Deleting empty directory "%s".', p)
       if not dry_run:
-        _RmTree(p)
+        shutil.rmtree(p, False)
 
   return deleted
 
 
 def _Download(url):
   """Downloads the given URL and returns the contents as a string."""
   response = urllib2.urlopen(url)
   if response.code != 200:
     raise RuntimeError('Failed to download "%s".' % url)
   return response.read()
@@ skipping 91 matching lines @@
   if not _REVISION_RE.match(options.revision):
     option_parser.error('Must specify a valid SVN or GIT revision.')
 
   # This just makes output prettier to read.
   options.output_dir = os.path.normpath(options.output_dir)
 
   return options
 
 
 def main():
-  # We only care about Windows platforms, as the Syzygy binaries aren't used
-  # elsewhere.
-  if sys.platform != 'win32':
-    return
-
   options = _ParseCommandLine()
 
   if options.dry_run:
     _LOGGER.debug('Performing a dry-run.')
 
   # Load the current installation state, and validate it against the
   # requested installation.
   state, is_consistent = _GetCurrentState(options.revision, options.output_dir)
 
   # Decide whether or not an install is necessary.
   if options.force:
     _LOGGER.debug('Forcing reinstall of binaries.')
   elif is_consistent:
     # Avoid doing any work if the contents of the directory are consistent.
     _LOGGER.debug('State unchanged, no reinstall necessary.')
     return
 
   # Under normal logging this is the only only message that will be reported.
   _LOGGER.info('Installing revision %s Syzygy binaries.',
                options.revision[0:12])
 
   # Clean up the old state to begin with.
   deleted = []
   if options.overwrite:
     if os.path.exists(options.output_dir):
       # If overwrite was specified then take a heavy-handed approach.
       _LOGGER.debug('Deleting entire installation directory.')
       if not options.dry_run:
-        _RmTree(options.output_dir)
+        shutil.rmtree(options.output_dir, False)
   else:
     # Otherwise only delete things that the previous installation put in place,
     # and take care to preserve any local changes.
     deleted = _CleanState(options.output_dir, state, options.dry_run)
 
   # Install the new binaries. In a dry-run this will actually download the
   # archives, but it won't write anything to disk.
   state = _InstallBinaries(options, deleted)
 
   # Build and save the state for the directory.
   _SaveState(options.output_dir, state, options.dry_run)
 
 
 if __name__ == '__main__':
   main()