Shorten RemoveDirectory and rename to rmtree. Remove rmtree from fake_repos.

tests/fake_repos.py

 #!/usr/bin/python
 # Copyright (c) 2010 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.
 
 """Generate fake repositories for testing."""
 
 import atexit
 import datetime
-import errno
 import logging
 import os
 import pprint
 import re
 import socket
-import stat
 import subprocess
 import sys
 import tempfile
-import time
 
 # trial_dir must be first for non-system libraries.
 from tests import trial_dir
+import gclient_utils
 import scm
 
 ## Utility functions
 
 
 def kill_pid(pid):
   """Kills a process by its process id."""
   try:
     # Unable to import 'module'
     # pylint: disable=F0401
@@ skipping 25 matching lines @@
     return
 
   if sys.platform == 'win32':
     subprocess.Popen.kill = kill_win
   else:
     def kill_nix(process):
       return kill_pid(process.pid)
     subprocess.Popen.kill = kill_nix
 
 
-def rmtree(*path):
-  """Recursively removes a directory, even if it's marked read-only.
-
-  Remove the directory located at *path, if it exists.
-
-  shutil.rmtree() doesn't work on Windows if any of the files or directories
-  are read-only, which svn repositories and some .svn files are.  We need to
-  be able to force the files to be writable (i.e., deletable) as we traverse
-  the tree.
-
-  Even with all this, Windows still sometimes fails to delete a file, citing
-  a permission error (maybe something to do with antivirus scans or disk
-  indexing).  The best suggestion any of the user forums had was to wait a
-  bit and try again, so we do that too.  It's hand-waving, but sometimes it
-  works. :/
-  """
-  file_path = os.path.join(*path)
-  if not os.path.exists(file_path):
-    return
-
-  def RemoveWithRetry_win(rmfunc, path):
-    os.chmod(path, stat.S_IWRITE)
-    if win32_api_avail:
-      win32api.SetFileAttributes(path, win32con.FILE_ATTRIBUTE_NORMAL)
-    try:
-      return rmfunc(path)
-    except EnvironmentError, e:
-      if e.errno != errno.EACCES:
-        raise
-      print 'Failed to delete %s: trying again' % repr(path)
-      time.sleep(0.1)
-      return rmfunc(path)
-
-  def RemoveWithRetry_non_win(rmfunc, path):
-    if os.path.islink(path):
-      return os.remove(path)
-    else:
-      return rmfunc(path)
-
-  win32_api_avail = False
-  remove_with_retry = None
-  if sys.platform.startswith('win'):
-    # Some people don't have the APIs installed. In that case we'll do without.
-    try:
-      win32api = __import__('win32api')
-      win32con = __import__('win32con')
-      win32_api_avail = True
-    except ImportError:
-      pass
-    remove_with_retry = RemoveWithRetry_win
-  else:
-    remove_with_retry = RemoveWithRetry_non_win
-
-  for root, dirs, files in os.walk(file_path, topdown=False):
-    # For POSIX:  making the directory writable guarantees removability.
-    # Windows will ignore the non-read-only bits in the chmod value.
-    os.chmod(root, 0770)
-    for name in files:
-      remove_with_retry(os.remove, os.path.join(root, name))
-    for name in dirs:
-      remove_with_retry(os.rmdir, os.path.join(root, name))
-
-  remove_with_retry(os.rmdir, file_path)
-
-
 def write(path, content):
   f = open(path, 'wb')
   f.write(content)
   f.close()
 
 
 join = os.path.join
 
 
 def check_call(*args, **kwargs):
@@ skipping 158 matching lines @@
     self.trial = None
 
   def tear_down_svn(self):
     if self.svnserve:
       logging.debug('Killing svnserve pid %s' % self.svnserve.pid)
       self.svnserve.kill()
       self.wait_for_port_to_free(self.svn_port)
       self.svnserve = None
       if not self.trial.SHOULD_LEAK:
         logging.debug('Removing %s' % self.svn_repo)
-        rmtree(self.svn_repo)
+        gclient_utils.rmtree(self.svn_repo)
         logging.debug('Removing %s' % self.svn_checkout)
-        rmtree(self.svn_checkout)
+        gclient_utils.rmtree(self.svn_checkout)
       else:
         return False
     return True
 
   def tear_down_git(self):
     if self.gitdaemon:
       logging.debug('Killing git-daemon pid %s' % self.gitdaemon.pid)
       self.gitdaemon.kill()
       self.gitdaemon = None
       if self.git_pid_file:
         pid = int(self.git_pid_file.read())
         self.git_pid_file.close()
         logging.debug('Killing git daemon pid %s' % pid)
         kill_pid(pid)
         self.git_pid_file = None
       self.wait_for_port_to_free(self.git_port)
       if not self.trial.SHOULD_LEAK:
         logging.debug('Removing %s' % self.git_root)
-        rmtree(self.git_root)
+        gclient_utils.rmtree(self.git_root)
       else:
         return False
     return True
 
   @staticmethod
   def _genTree(root, tree_dict):
     """For a dictionary of file contents, generate a filesystem."""
     if not os.path.isdir(root):
       os.makedirs(root)
     for (k, v) in tree_dict.iteritems():
@@ skipping 450 matching lines @@
     fake.set_up_git()
     print('Fake setup, press enter to quit or Ctrl-C to keep the checkouts.')
     sys.stdin.readline()
   except KeyboardInterrupt:
     trial_dir.TrialDir.SHOULD_LEAK.leak = True
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))