Remove SVN and File support from gclient

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
-"""Meta checkout manager supporting both Subversion and GIT."""
+"""Meta checkout dependency manager for Git."""
 # Files
 #   .gclient      : Current client configuration, written by 'config' command.
 #                   Format is a Python script defining 'solutions', a list whose
 #                   entries each are maps binding the strings "name" and "url"
 #                   to strings specifying the name and location of the client
 #                   module, as well as "custom_deps" to a map similar to the
 #                   deps section of the DEPS file below, as well as
 #                   "custom_hooks" to a list similar to the hooks sections of
 #                   the DEPS file below.
 #   .gclient_entries : A cache constructed by 'update' command.  Format is a
@@ skipping 149 matching lines @@
 
       sub_target_name is an optional parameter if the module name in the other
       DEPS file is different. E.g., you might want to map src/net to net."""
       self.module_name = module_name
       self.sub_target_name = sub_target_name
 
     def __str__(self):
       return 'From(%s, %s)' % (repr(self.module_name),
                                repr(self.sub_target_name))
 
-  class FileImpl(object):
-    """Used to implement the File('') syntax which lets you sync a single file
-    from a SVN repo."""
-
-    def __init__(self, file_location):
-      self.file_location = file_location
-
-    def __str__(self):
-      return 'File("%s")' % self.file_location
-
-    def GetPath(self):
-      return os.path.split(self.file_location)[0]
-
-    def GetFilename(self):
-      rev_tokens = self.file_location.split('@')
-      return os.path.split(rev_tokens[0])[1]
-
-    def GetRevision(self):
-      rev_tokens = self.file_location.split('@')
-      if len(rev_tokens) > 1:
-        return rev_tokens[1]
-      return None
-
   class VarImpl(object):
     def __init__(self, custom_vars, local_scope):
       self._custom_vars = custom_vars
       self._local_scope = local_scope
 
     def Lookup(self, var_name):
       """Implements the Var syntax."""
       if var_name in self._custom_vars:
         return self._custom_vars[var_name]
       elif var_name in self._local_scope.get("vars", {}):
@@ skipping 28 matching lines @@
     self._relative = relative
     # This is a mutable value which has the list of 'target_os' OSes listed in
     # the current deps file.
     self.local_target_os = None
 
     # These are only set in .gclient and not in DEPS files.
     self._custom_vars = custom_vars or {}
     self._custom_deps = custom_deps or {}
     self._custom_hooks = custom_hooks or []
 
-    # TODO(iannucci): Remove this when all masters are correctly substituting
-    # the new blink url.
-    if (self._custom_vars.get('webkit_trunk', '') ==
-        'svn://svn-mirror.golo.chromium.org/webkit-readonly/trunk'):
-      new_url = 'svn://svn-mirror.golo.chromium.org/blink/trunk'
-      print('Overwriting Var("webkit_trunk") with %s' % new_url)
-      self._custom_vars['webkit_trunk'] = new_url
-
     # Post process the url to remove trailing slashes.
     if isinstance(self._url, basestring):
       # urls are sometime incorrectly written as proto://host/path/@rev. Replace
       # it to proto://host/path@rev.
       self._url = self._url.replace('/@', '@')
-    elif not isinstance(self._url,
-        (self.FromImpl, self.FileImpl, None.__class__)):
+    elif not isinstance(self._url, (self.FromImpl, None.__class__)):
       raise gclient_utils.Error(
           ('dependency url must be either a string, None, '
-           'File() or From() instead of %s') % self._url.__class__.__name__)
+           'or From() instead of %s') % self._url.__class__.__name__)
     # Make any deps_file path platform-appropriate.
     for sep in ['/', '\\']:
       self._deps_file = self._deps_file.replace(sep, os.sep)
 
   @property
   def deps_file(self):
     return self._deps_file
 
   @property
   def managed(self):
@@ skipping 252 matching lines @@
       parsed_url = urlparse.urlparse(url)
       if (not parsed_url[0] and
           not re.match(r'^\w+\@[\w\.-]+\:[\w\/]+', parsed_url[2])):
         # A relative url. Fetch the real base.
         path = parsed_url[2]
         if not path.startswith('/'):
           raise gclient_utils.Error(
               'relative DEPS entry \'%s\' must begin with a slash' % url)
         # Create a scm just to query the full url.
         parent_url = self.parent.parsed_url
-        if isinstance(parent_url, self.FileImpl):
-          parent_url = parent_url.file_location
         scm = gclient_scm.CreateSCM(
             parent_url, self.root.root_dir, None, self.outbuf)
         parsed_url = scm.FullUrlForRelativeUrl(url)
       else:
         parsed_url = url
       logging.info(
           'Dependency(%s).LateOverride(%s) -> %s' %
           (self.name, url, parsed_url))
       return parsed_url
 
-    if isinstance(url, self.FileImpl):
-      logging.info(
-          'Dependency(%s).LateOverride(%s) -> %s (File)' %
-          (self.name, url, url))
-      return url
-
     if url is None:
       logging.info(
           'Dependency(%s).LateOverride(%s) -> %s' % (self.name, url, url))
       return url
 
     raise gclient_utils.Error('Unknown url type')
 
   @staticmethod
   def MergeWithOsDeps(deps, deps_os, target_os_list):
     """Returns a new "deps" structure that is the deps sent in updated
@@ skipping 70 matching lines @@
       if use_strict:
         logging.info(
           'ParseDepsFile(%s): Strict Mode Enabled', self.name)
         global_scope = {
           '__builtins__': {'None': None},
           'Var': var.Lookup,
           'deps_os': {},
         }
       else:
         global_scope = {
-          'File': self.FileImpl,
           'From': self.FromImpl,
           'Var': var.Lookup,
           'deps_os': {},
         }
       # Eval the content.
       try:
         exec(deps_content, global_scope, local_scope)
       except SyntaxError as e:
         gclient_utils.SyntaxErrorToError(filepath, e)
       if use_strict:
@@ skipping 110 matching lines @@
     self.add_dependencies_and_close(deps_to_add, hooks_to_run)
     logging.info('ParseDepsFile(%s) done' % self.name)
 
   def add_dependencies_and_close(self, deps_to_add, hooks):
     """Adds the dependencies, hooks and mark the parsing as done."""
     for dep in deps_to_add:
       if dep.verify_validity():
         self.add_dependency(dep)
     self._mark_as_parsed(hooks)
 
-  def maybeGetParentRevision(self, command, options, parsed_url, parent):
-    """Uses revision/timestamp of parent if no explicit revision was specified.
-
-    If we are performing an update and --transitive is set, use
-    - the parent's revision if 'self.url' is in the same repository
-    - the parent's timestamp otherwise
-    to update 'self.url'. The used revision/timestamp will be set in
-    'options.revision'.
-    If we have an explicit revision do nothing.
-    """
-    if command == 'update' and options.transitive and not options.revision:
-      _, revision = gclient_utils.SplitUrlRevision(parsed_url)
-      if not revision:
-        options.revision = getattr(parent, '_used_revision', None)
-        if (options.revision and
-            not gclient_utils.IsDateRevision(options.revision)):
-          assert self.parent and self.parent.used_scm
-          # If this dependency is in the same repository as parent it's url will
-          # start with a slash. If so we take the parent revision instead of
-          # it's timestamp.
-          # (The timestamps of commits in google code are broken -- which can
-          # result in dependencies to be checked out at the wrong revision)
-          if self.url.startswith('/'):
-            if options.verbose:
-              print('Using parent\'s revision %s since we are in the same '
-                    'repository.' % options.revision)
-          else:
-            parent_revision_date = self.parent.used_scm.GetRevisionDate(
-                options.revision)
-            options.revision = gclient_utils.MakeDateRevision(
-                parent_revision_date)
-            if options.verbose:
-              print('Using parent\'s revision date %s since we are in a '
-                    'different repository.' % options.revision)
-
   def findDepsFromNotAllowedHosts(self):
     """Returns a list of depenecies from not allowed hosts.
 
     If allowed_hosts is not set, allows all hosts and returns empty list.
     """
     if not self._allowed_hosts:
       return []
     bad_deps = []
     for dep in self._dependencies:
       # Don't enforce this for custom_deps.
@@ skipping 14 matching lines @@
     if not self.should_process:
       return
     # When running runhooks, there's no need to consult the SCM.
     # All known hooks are expected to run unconditionally regardless of working
     # copy state, so skip the SCM status check.
     run_scm = command not in ('runhooks', 'recurse', None)
     parsed_url = self.LateOverride(self.url)
     file_list = [] if not options.nohooks else None
     revision_override = revision_overrides.pop(self.name, None)
     if run_scm and parsed_url:
-      if isinstance(parsed_url, self.FileImpl):
-        # Special support for single-file checkout.
-        if not command in (None, 'cleanup', 'diff', 'pack', 'status'):
-          # Sadly, pylint doesn't realize that parsed_url is of FileImpl.
-          # pylint: disable=E1103
-          options.revision = parsed_url.GetRevision()
-          self._used_scm = gclient_scm.SVNWrapper(
-              parsed_url.GetPath(), self.root.root_dir, self.name,
-              out_cb=work_queue.out_cb)
-          self._used_scm.RunCommand('updatesingle',
-              options, args + [parsed_url.GetFilename()], file_list)
-      else:
-        # Create a shallow copy to mutate revision.
-        options = copy.copy(options)
-        options.revision = revision_override
-        self.maybeGetParentRevision(
-            command, options, parsed_url, self.parent)
-        self._used_revision = options.revision
-        self._used_scm = gclient_scm.CreateSCM(
-            parsed_url, self.root.root_dir, self.name, self.outbuf,
-            out_cb=work_queue.out_cb)
-        self._got_revision = self._used_scm.RunCommand(command, options, args,
-                                                       file_list)
-        if file_list:
-          file_list = [os.path.join(self.name, f.strip()) for f in file_list]
+      # Create a shallow copy to mutate revision.
+      options = copy.copy(options)
+      options.revision = revision_override
+      self._used_revision = options.revision
+      self._used_scm = gclient_scm.CreateSCM(
+          parsed_url, self.root.root_dir, self.name, self.outbuf,
+          out_cb=work_queue.out_cb)
+      self._got_revision = self._used_scm.RunCommand(command, options, args,
+                                                     file_list)
+      if file_list:
+        file_list = [os.path.join(self.name, f.strip()) for f in file_list]
 
       # TODO(phajdan.jr): We should know exactly when the paths are absolute.
       # Convert all absolute paths to relative.
       for i in range(len(file_list or [])):
         # It depends on the command being executed (like runhooks vs sync).
         if not os.path.isabs(file_list[i]):
           continue
         prefix = os.path.commonprefix(
             [self.root.root_dir.lower(), file_list[i].lower()])
         file_list[i] = file_list[i][len(prefix):]
         # Strip any leading path separators.
         while file_list[i].startswith(('\\', '/')):
           file_list[i] = file_list[i][1:]
 
     # Always parse the DEPS file.
     self.ParseDepsFile()
     self._run_is_done(file_list or [], parsed_url)
     if command in ('update', 'revert') and not options.noprehooks:
       self.RunPreDepsHooks()
 
     if self.recursion_limit:
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         work_queue.enqueue(s)
 
     if command == 'recurse':
-      if not isinstance(parsed_url, self.FileImpl):
-        # Skip file only checkout.
-        scm = gclient_scm.GetScmName(parsed_url)
-        if not options.scm or scm in options.scm:
-          cwd = os.path.normpath(os.path.join(self.root.root_dir, self.name))
-          # Pass in the SCM type as an env variable.  Make sure we don't put
-          # unicode strings in the environment.
-          env = os.environ.copy()
-          if scm:
-            env['GCLIENT_SCM'] = str(scm)
-          if parsed_url:
-            env['GCLIENT_URL'] = str(parsed_url)
-          env['GCLIENT_DEP_PATH'] = str(self.name)
-          if options.prepend_dir and scm == 'git':
-            print_stdout = False
-            def filter_fn(line):
-              """Git-specific path marshaling. It is optimized for git-grep."""
+      # Skip file only checkout.
+      scm = gclient_scm.GetScmName(parsed_url)
+      if not options.scm or scm in options.scm:
+        cwd = os.path.normpath(os.path.join(self.root.root_dir, self.name))
+        # Pass in the SCM type as an env variable.  Make sure we don't put
+        # unicode strings in the environment.
+        env = os.environ.copy()
+        if scm:
+          env['GCLIENT_SCM'] = str(scm)
+        if parsed_url:
+          env['GCLIENT_URL'] = str(parsed_url)
+        env['GCLIENT_DEP_PATH'] = str(self.name)
+        if options.prepend_dir and scm == 'git':
+          print_stdout = False
+          def filter_fn(line):
+            """Git-specific path marshaling. It is optimized for git-grep."""
 
-              def mod_path(git_pathspec):
-                match = re.match('^(\\S+?:)?([^\0]+)$', git_pathspec)
-                modified_path = os.path.join(self.name, match.group(2))
-                branch = match.group(1) or ''
-                return '%s%s' % (branch, modified_path)
+            def mod_path(git_pathspec):
+              match = re.match('^(\\S+?:)?([^\0]+)$', git_pathspec)
+              modified_path = os.path.join(self.name, match.group(2))
+              branch = match.group(1) or ''
+              return '%s%s' % (branch, modified_path)
 
-              match = re.match('^Binary file ([^\0]+) matches$', line)
-              if match:
-                print('Binary file %s matches\n' % mod_path(match.group(1)))
-                return
+            match = re.match('^Binary file ([^\0]+) matches$', line)
+            if match:
+              print('Binary file %s matches\n' % mod_path(match.group(1)))
+              return
 
-              items = line.split('\0')
-              if len(items) == 2 and items[1]:
-                print('%s : %s' % (mod_path(items[0]), items[1]))
-              elif len(items) >= 2:
-                # Multiple null bytes or a single trailing null byte indicate
-                # git is likely displaying filenames only (such as with -l)
-                print('\n'.join(mod_path(path) for path in items if path))
-              else:
-                print(line)
-          else:
-            print_stdout = True
-            filter_fn = None
+            items = line.split('\0')
+            if len(items) == 2 and items[1]:
+              print('%s : %s' % (mod_path(items[0]), items[1]))
+            elif len(items) >= 2:
+              # Multiple null bytes or a single trailing null byte indicate
+              # git is likely displaying filenames only (such as with -l)
+              print('\n'.join(mod_path(path) for path in items if path))
+            else:
+              print(line)
+        else:
+          print_stdout = True
+          filter_fn = None
 
-          if parsed_url is None:
-            print('Skipped omitted dependency %s' % cwd, file=sys.stderr)
-          elif os.path.isdir(cwd):
-            try:
-              gclient_utils.CheckCallAndFilter(
-                  args, cwd=cwd, env=env, print_stdout=print_stdout,
-                  filter_fn=filter_fn,
-                  )
-            except subprocess2.CalledProcessError:
-              if not options.ignore:
-                raise
-          else:
-            print('Skipped missing %s' % cwd, file=sys.stderr)
+        if parsed_url is None:
+          print('Skipped omitted dependency %s' % cwd, file=sys.stderr)
+        elif os.path.isdir(cwd):
+          try:
+            gclient_utils.CheckCallAndFilter(
+                args, cwd=cwd, env=env, print_stdout=print_stdout,
+                filter_fn=filter_fn,
+                )
+          except subprocess2.CalledProcessError:
+            if not options.ignore:
+              raise
+        else:
+          print('Skipped missing %s' % cwd, file=sys.stderr)
 
 
   @gclient_utils.lockedmethod
   def _run_is_done(self, file_list, parsed_url):
     # Both these are kept for hooks that are run as a separate tree traversal.
     self._file_list = file_list
     self._parsed_url = parsed_url
     self._processed = True
 
   @staticmethod
@@ skipping 17 matching lines @@
 
     RunOnDeps() must have been called before to load the DEPS.
     """
     result = []
     if not self.should_process or not self.recursion_limit:
       # Don't run the hook when it is above recursion_limit.
       return result
     # If "--force" was specified, run all hooks regardless of what files have
     # changed.
     if self.deps_hooks:
-      # TODO(maruel): If the user is using git or git-svn, then we don't know
+      # TODO(maruel): If the user is using git, then we don't know
       # what files have changed so we always run all hooks. It'd be nice to fix
       # that.
       if (options.force or
-          isinstance(self.parsed_url, self.FileImpl) or
           gclient_scm.GetScmName(self.parsed_url) in ('git', None) or
           os.path.isdir(os.path.join(self.root.root_dir, self.name, '.git'))):
         for hook_dict in self.deps_hooks:
           result.append(self.GetHookAction(hook_dict, []))
       else:
         # Run hooks on the basis of whether the files from the gclient operation
         # match each hook's pattern.
         for hook_dict in self.deps_hooks:
           pattern = re.compile(hook_dict['pattern'])
           matching_file_list = [
@@ skipping 263 matching lines @@
 is actually checked out in %(checkout_path)s.
 
 The .gclient file contains:
 URL: %(expected_url)s (%(expected_scm)s)
 Cache mirror: %(mirror_string)s
 
 The local checkout in %(checkout_path)s reports:
 %(actual_url)s (%(actual_scm)s)
 
 You should ensure that the URL listed in .gclient is correct and either change
-it or fix the checkout. If you're managing your own git checkout in
-%(checkout_path)s but the URL in .gclient is for an svn repository, you probably
-want to set 'managed': False in .gclient.
+it or fix the checkout.
 '''  % {'checkout_path': os.path.join(self.root_dir, dep.name),
         'expected_url': dep.url,
         'expected_scm': gclient_scm.GetScmName(dep.url),
         'mirror_string' : mirror_string,
         'actual_url': actual_url,
         'actual_scm': gclient_scm.GetScmName(actual_url)})
 
   def SetConfig(self, content):
     assert not self.dependencies
     config_dict = {}
@@ skipping 42 matching lines @@
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     self.add_dependencies_and_close(deps_to_add, config_dict.get('hooks', []))
     logging.info('SetConfig() done')
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir,
                                          self._options.config_filename),
                             self.config_content)
 
-  def MigrateConfigToGit(self, path, options):
-    svn_url_re = re.compile('^(https?://src\.chromium\.org/svn|'
-                            'svn://svn\.chromium\.org/chrome)/'
-                            '(trunk|branches/[^/]+)/src')
-    old_git_re = re.compile('^(https?://git\.chromium\.org|'
-                            'ssh://([a-zA-Z_][a-zA-Z0-9_-]*@)?'
-                            'gerrit\.chromium\.org(:2941[89])?)/'
-                            'chromium/src\.git')
-    # Scan existing .gclient file for obsolete settings.  It would be simpler
-    # to traverse self.dependencies, but working with the AST allows the code to
-    # dump an updated .gclient file that preserves the ordering of the original.
-    a = ast.parse(self.config_content, options.config_filename, 'exec')
-    modified = False
-    solutions = [elem for elem in a.body if 'solutions' in
-                 [target.id for target in elem.targets]]
-    if not solutions:
-      return self
-    solutions = solutions[-1]
-    for solution in solutions.value.elts:
-      # Check for obsolete URL's
-      url_idx = ast_dict_index(solution, 'url')
-      if url_idx == -1:
-        continue
-      url_val = solution.values[url_idx]
-      if type(url_val) is not ast.Str:
-        continue
-      if (svn_url_re.match(url_val.s.strip())):
-        raise gclient_utils.Error(
-"""
-The chromium code repository has migrated completely to git.
-Your SVN-based checkout is now obsolete; you need to create a brand-new
-git checkout by following these instructions:
-
-http://www.chromium.org/developers/how-tos/get-the-code
-""")
-      if (old_git_re.match(url_val.s.strip())):
-        url_val.s = CHROMIUM_SRC_URL
-        modified = True
-
-      # Ensure deps_file is set to .DEPS.git.  We enforce this here to smooth
-      # over switching between pre-git-migration and post-git-migration
-      # revisions.
-      #   - For pre-migration revisions, .DEPS.git must be explicitly set.
-      #   - For post-migration revisions, .DEPS.git is not present, so gclient
-      #     will correctly fall back to DEPS.
-      if url_val.s == CHROMIUM_SRC_URL:
-        deps_file_idx = ast_dict_index(solution, 'deps_file')
-        if deps_file_idx != -1:
-          continue
-        solution.keys.append(ast.Str('deps_file'))
-        solution.values.append(ast.Str('.DEPS.git'))
-        modified = True
-
-    if not modified:
-      return self
-
-    print(
-"""
-WARNING: gclient detected an obsolete setting in your %s file.  The file has
-been automagically updated.  The previous version is available at %s.old.
-""" % (options.config_filename, options.config_filename))
-
-    # Replace existing .gclient with the updated version.
-    # Return a new GClient instance based on the new content.
-    new_content = ast2str(a)
-    dot_gclient_fn = os.path.join(path, options.config_filename)
-    try:
-      os.rename(dot_gclient_fn, dot_gclient_fn + '.old')
-    except OSError:
-      pass
-    with open(dot_gclient_fn, 'w') as fh:
-      fh.write(new_content)
-    client = GClient(path, options)
-    client.SetConfig(new_content)
-    return client
-
   @staticmethod
   def LoadCurrentConfig(options):
     """Searches for and loads a .gclient file relative to the current working
     dir. Returns a GClient object."""
     if options.spec:
       client = GClient('.', options)
       client.SetConfig(options.spec)
     else:
       if options.verbose:
         print('Looking for %s starting from %s\n' % (
             options.config_filename, os.getcwd()))
       path = gclient_utils.FindGclientRoot(os.getcwd(), options.config_filename)
       if not path:
         return None
       client = GClient(path, options)
       client.SetConfig(gclient_utils.FileRead(
           os.path.join(path, options.config_filename)))
-      client = client.MigrateConfigToGit(path, options)
 
     if (options.revisions and
         len(client.dependencies) > 1 and
         any('@' not in r for r in options.revisions)):
       print(
           ('You must specify the full solution name like --revision %s@%s\n'
            'when you have multiple solutions setup in your .gclient file.\n'
            'Other solutions present are: %s.') % (
               client.dependencies[0].name,
               options.revisions[0],
@@ skipping 14 matching lines @@
 
   def _SaveEntries(self):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
     result = 'entries = {\n'
     for entry in self.root.subtree(False):
-      # Skip over File() dependencies as we can't version them.
-      if not isinstance(entry.parsed_url, self.FileImpl):
-        result += '  %s: %s,\n' % (pprint.pformat(entry.name),
-            pprint.pformat(entry.parsed_url))
+      result += '  %s: %s,\n' % (pprint.pformat(entry.name),
+          pprint.pformat(entry.parsed_url))
     result += '}\n'
     file_path = os.path.join(self.root_dir, self._options.entries_filename)
     logging.debug(result)
     gclient_utils.FileWrite(file_path, result)
 
   def _ReadEntries(self):
     """Read the .gclient_entries file for the given client.
 
     Returns:
       A sequence of solution names, which will be empty if there is the
@@ skipping 109 matching lines @@
         e_dir = os.path.join(self.root_dir, entry_fixed)
         # Use entry and not entry_fixed there.
         if (entry not in entries and
             (not any(path.startswith(entry + '/') for path in entries)) and
             os.path.exists(e_dir)):
           # The entry has been removed from DEPS.
           scm = gclient_scm.CreateSCM(
               prev_url, self.root_dir, entry_fixed, self.outbuf)
 
           # Check to see if this directory is now part of a higher-up checkout.
-          # The directory might be part of a git OR svn checkout.
           scm_root = None
-          scm_class = None
-          for scm_class in (gclient_scm.scm.GIT, gclient_scm.scm.SVN):
-            try:
-              scm_root = scm_class.GetCheckoutRoot(scm.checkout_path)
-            except subprocess2.CalledProcessError:
-              pass
-            if scm_root:
-              break
-          else:
+          try:
+            scm_root = gclient_scm.scm.GIT.GetCheckoutRoot(scm.checkout_path)
+          except subprocess2.CalledProcessError:
+            pass
+          if not scm_root:
             logging.warning('Could not find checkout root for %s. Unable to '
                             'determine whether it is part of a higher-level '
                             'checkout, so not removing.' % entry)
             continue
 
           # This is to handle the case of third_party/WebKit migrating from
           # being a DEPS entry to being part of the main project.
           # If the subproject is a Git project, we need to remove its .git
           # folder. Otherwise git operations on that folder will have different
           # effects depending on the current working directory.
-          if scm_class == gclient_scm.scm.GIT and (
-              os.path.abspath(scm_root) == os.path.abspath(e_dir)):
+          if os.path.abspath(scm_root) == os.path.abspath(e_dir):
             e_par_dir = os.path.join(e_dir, os.pardir)
-            if scm_class.IsInsideWorkTree(e_par_dir):
-              par_scm_root = scm_class.GetCheckoutRoot(e_par_dir)
+            if gclient_scm.scm.GIT.IsInsideWorkTree(e_par_dir):
+              par_scm_root = gclient_scm.scm.GIT.GetCheckoutRoot(e_par_dir)
               # rel_e_dir : relative path of entry w.r.t. its parent repo.
               rel_e_dir = os.path.relpath(e_dir, par_scm_root)
-              if scm_class.IsDirectoryVersioned(par_scm_root, rel_e_dir):
+              if gclient_scm.scm.GIT.IsDirectoryVersioned(
+                  par_scm_root, rel_e_dir):
                 save_dir = scm.GetGitBackupDirPath()
                 # Remove any eventual stale backup dir for the same project.
                 if os.path.exists(save_dir):
                   gclient_utils.rmtree(save_dir)
                 os.rename(os.path.join(e_dir, '.git'), save_dir)
                 # When switching between the two states (entry/ is a subproject
                 # -> entry/ is part of the outer project), it is very likely
                 # that some files are changed in the checkout, unless we are
                 # jumping *exactly* across the commit which changed just DEPS.
                 # In such case we want to cleanup any eventual stale files
                 # (coming from the old subproject) in order to end up with a
                 # clean checkout.
-                scm_class.CleanupDir(par_scm_root, rel_e_dir)
+                gclient_scm.scm.GIT.CleanupDir(par_scm_root, rel_e_dir)
                 assert not os.path.exists(os.path.join(e_dir, '.git'))
                 print(('\nWARNING: \'%s\' has been moved from DEPS to a higher '
                        'level checkout. The git folder containing all the local'
                        ' branches has been saved to %s.\n'
                        'If you don\'t care about its state you can safely '
                        'remove that folder to free up space.') %
                       (entry, save_dir))
                 continue
 
           if scm_root in full_entries:
@@ skipping 27 matching lines @@
     work_queue = gclient_utils.ExecutionQueue(
         self._options.jobs, None, False, verbose=self._options.verbose)
     for s in self.dependencies:
       work_queue.enqueue(s)
     work_queue.flush({}, None, [], options=self._options)
 
     def GetURLAndRev(dep):
       """Returns the revision-qualified SCM url for a Dependency."""
       if dep.parsed_url is None:
         return None
-      if isinstance(dep.parsed_url, self.FileImpl):
-        original_url = dep.parsed_url.file_location
-      else:
-        original_url = dep.parsed_url
-      url, _ = gclient_utils.SplitUrlRevision(original_url)
+      url, _ = gclient_utils.SplitUrlRevision(dep.parsed_url)
       scm = gclient_scm.CreateSCM(
-          original_url, self.root_dir, dep.name, self.outbuf)
+          dep.parsed_url, self.root_dir, dep.name, self.outbuf)
       if not os.path.isdir(scm.checkout_path):
         return None
       return '%s@%s' % (url, scm.revinfo(self._options, [], None))
 
     if self._options.snapshot:
       new_gclient = ''
       # First level at .gclient
       for d in self.dependencies:
         entries = {}
         def GrabDeps(dep):
@@ skipping 63 matching lines @@
 
   @property
   def target_os(self):
     return self._enforced_os
 
 
 #### gclient commands.
 
 
 def CMDcleanup(parser, args):
-  """Cleans up all working copies.
+  """DEPRECATED: SVN-only. Cleaned up all working copies.
 
-  Mostly svn-specific. Simply runs 'svn cleanup' for each module.
+  This is a no-op in Git.
   """
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
     raise gclient_utils.Error('client not configured; see \'gclient config\'')
   if options.verbose:
@@ skipping 162 matching lines @@
   return 0
 
 
 @subcommand.epilog("""Example:
   gclient pack > patch.txt
     generate simple patch for configured client and dependences
 """)
 def CMDpack(parser, args):
   """Generates a patch which can be applied at the root of the tree.
 
-  Internally, runs 'svn diff'/'git diff' on each checked out module and
+  Internally, runs 'git diff' on each checked out module and
   dependencies, and performs minimal postprocessing of the output. The
   resulting patch is printed to stdout and can be applied to a freshly
   checked out tree via 'patch -p0 < patchfile'.
   """
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
   parser.remove_option('--jobs')
   (options, args) = parser.parse_args(args)
@@ skipping 34 matching lines @@
 
 JSON output format:
 If the --output-json option is specified, the following document structure will
 be emitted to the provided file. 'null' entries may occur for subprojects which
 are present in the gclient solution, but were not processed (due to custom_deps,
 os_deps, etc.)
 
 {
   "solutions" : {
     "<name>": {  # <name> is the posix-normalized path to the solution.
-      "revision": [<svn rev int>|<git id hex string>|null],
-      "scm": ["svn"|"git"|null],
+      "revision": [<git id hex string>|null],
+      "scm": ["git"|null],
     }
   }
 }
 """)
 def CMDsync(parser, args):
   """Checkout/update all modules."""
   parser.add_option('-f', '--force', action='store_true',
                     help='force update even for unchanged modules')
   parser.add_option('-n', '--nohooks', action='store_true',
                     help='don\'t run hooks after the update is complete')
   parser.add_option('-p', '--noprehooks', action='store_true',
                     help='don\'t run pre-DEPS hooks', default=False)
   parser.add_option('-r', '--revision', action='append',
                     dest='revisions', metavar='REV', default=[],
                     help='Enforces revision/hash for the solutions with the '
                          'format src@rev. The src@ part is optional and can be '
                          'skipped. -r can be used multiple times when .gclient '
                          'has multiple solutions configured and will work even '
                          'if the src@ part is skipped. Note that specifying '
                          '--revision means your safesync_url gets ignored.')
   parser.add_option('--with_branch_heads', action='store_true',
                     help='Clone git "branch_heads" refspecs in addition to '
                          'the default refspecs. This adds about 1/2GB to a '
                          'full checkout. (git only)')
   parser.add_option('--with_tags', action='store_true',
                     help='Clone git tags in addition to the default refspecs.')
-  parser.add_option('-t', '--transitive', action='store_true',
-                    help='When a revision is specified (in the DEPS file or '
-                          'with the command-line flag), transitively update '
-                          'the dependencies to the date of the given revision. '
-                          'Only supported for SVN repositories.')
   parser.add_option('-H', '--head', action='store_true',
                     help='skips any safesync_urls specified in '
                          'configured solutions and sync to head instead')
   parser.add_option('-D', '--delete_unversioned_trees', action='store_true',
                     help='Deletes from the working copy any dependencies that '
                          'have been removed since the last sync, as long as '
                          'there are no local modifications. When used with '
                          '--force, such dependencies are removed even if they '
                          'have local modifications. When used with --reset, '
                          'all untracked directories are removed from the '
                          'working copy, excluding those which are explicitly '
                          'ignored in the repository.')
   parser.add_option('-R', '--reset', action='store_true',
                     help='resets any local changes before updating (git only)')
   parser.add_option('-M', '--merge', action='store_true',
                     help='merge upstream changes instead of trying to '
                          'fast-forward or rebase')
   parser.add_option('-A', '--auto_rebase', action='store_true',
                     help='Automatically rebase repositories against local '
                          'checkout during update (git only).')
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
-  parser.add_option('-m', '--manually_grab_svn_rev', action='store_true',
-                    help='Skip svn up whenever possible by requesting '
-                         'actual HEAD revision from the repository')
   parser.add_option('--upstream', action='store_true',
                     help='Make repo state match upstream branch.')
   parser.add_option('--output-json',
                     help='Output a json document to this path containing '
                          'summary information about the sync.')
   parser.add_option('--no-history', action='store_true',
                     help='GIT ONLY - Reduces the size/time of the checkout at '
                     'the cost of no history. Requires Git 1.9+')
   parser.add_option('--shallow', action='store_true',
                     help='GIT ONLY - Do a shallow clone into the cache dir. '
@@ skipping 53 matching lines @@
     raise gclient_utils.Error('client not configured; see \'gclient config\'')
   if options.verbose:
     client.PrintLocationAndContents()
   return client.RunOnDeps('diff', args)
 
 
 def CMDrevert(parser, args):
   """Reverts all modifications in every dependencies.
 
   That's the nuclear option to get back to a 'clean' state. It removes anything
-  that shows up in svn status."""
+  that shows up in git status."""
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
   parser.add_option('-n', '--nohooks', action='store_true',
                     help='don\'t run hooks after the revert is complete')
   parser.add_option('-p', '--noprehooks', action='store_true',
                     help='don\'t run pre-DEPS hooks', default=False)
   parser.add_option('--upstream', action='store_true',
                     help='Make repo state match upstream branch.')
@@ skipping 31 matching lines @@
   options.force = True
   options.nohooks = False
   return client.RunOnDeps('runhooks', args)
 
 
 def CMDrevinfo(parser, args):
   """Outputs revision info mapping for the client and its dependencies.
 
   This allows the capture of an overall 'revision' for the source tree that
   can be used to reproduce the same tree in the future. It is only useful for
-  'unpinned dependencies', i.e. DEPS/deps references without a svn revision
-  number or a git hash. A git branch name isn't 'pinned' since the actual
-  commit can change.
+  'unpinned dependencies', i.e. DEPS/deps references without a git hash.
+  A git branch name isn't 'pinned' since the actual commit can change.
   """
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
   parser.add_option('-a', '--actual', action='store_true',
                     help='gets the actual checked out revisions instead of the '
                          'ones specified in the DEPS and .gclient files')
   parser.add_option('-s', '--snapshot', action='store_true',
                     help='creates a snapshot .gclient file of the current '
@@ skipping 45 matching lines @@
 
   def __init__(self, **kwargs):
     optparse.OptionParser.__init__(
         self, version='%prog ' + __version__, **kwargs)
 
     # Some arm boards have issues with parallel sync.
     if platform.machine().startswith('arm'):
       jobs = 1
     else:
       jobs = max(8, gclient_utils.NumLocalCpus())
-    # cmp: 2013/06/19
-    # Temporary workaround to lower bot-load on SVN server.
-    # Bypassed if a bot_update flag is detected.
-    if (os.environ.get('CHROME_HEADLESS') == '1' and
-        not os.path.exists('update.flag')):
-      jobs = 1
 
     self.add_option(
         '-j', '--jobs', default=jobs, type='int',
         help='Specify how many SCM commands can run in parallel; defaults to '
              '%default on this machine')
     self.add_option(
         '-v', '--verbose', action='count', default=0,
         help='Produces additional output for diagnostics. Can be used up to '
              'three times for more logging info.')
     self.add_option(
@@ skipping 30 matching lines @@
       # GClient.RunOnDeps expects it even if not applicable.
       options.revisions = []
     if not hasattr(options, 'head'):
       options.head = None
     if not hasattr(options, 'nohooks'):
       options.nohooks = True
     if not hasattr(options, 'noprehooks'):
       options.noprehooks = True
     if not hasattr(options, 'deps_os'):
       options.deps_os = None
-    if not hasattr(options, 'manually_grab_svn_rev'):
-      options.manually_grab_svn_rev = None
     if not hasattr(options, 'force'):
       options.force = None
     return (options, args)
 
 
 def disable_buffering():
   # Make stdout auto-flush so buildbot doesn't kill us during lengthy
   # operations. Python as a strong tendency to buffer sys.stdout.
   sys.stdout = gclient_utils.MakeFileAutoFlush(sys.stdout)
   # Make stdout annotated with the thread ids.
@@ skipping 32 matching lines @@
 
 
 if '__main__' == __name__:
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: